lattice-ui 0.4.3

package/dist/commands/selection.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveComponentSelection = resolveComponentSelection;
+const errors_1 = require("../core/errors");
+function resolveComponentSelection(ctx, input) {
+    const selected = new Set();
+    for (const name of input.names) {
+        if (!ctx.registry.packages[name]) {
+            throw (0, errors_1.usageError)(`Unknown component: ${name}`);
+        }
+        selected.add(name);
+    }
+    for (const preset of input.presets) {
+        const presetMembers = ctx.registry.presets[preset];
+        if (!presetMembers) {
+            throw (0, errors_1.usageError)(`Unknown preset: ${preset}`);
+        }
+        for (const member of presetMembers) {
+            selected.add(member);
+        }
+    }
+    const sorted = [...selected].sort((left, right) => left.localeCompare(right));
+    if (sorted.length === 0) {
+        throw (0, errors_1.usageError)("No components selected. Provide component names or --preset.");
+    }
+    return sorted;
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,3 @@
+import type { CliContext } from "../ctx";
+import { type SelectionInput } from "./selection";
+export declare function runUpgradeCommand(ctx: CliContext, input: SelectionInput): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpgradeCommand = runUpgradeCommand;
+const errors_1 = require("../core/errors");
+const output_1 = require("../core/output");
+const readPackageJson_1 = require("../core/project/readPackageJson");
+const prompt_1 = require("../core/prompt");
+const selection_1 = require("./selection");
+function getSelectedRegistryPackages(ctx, input) {
+    const components = (0, selection_1.resolveComponentSelection)(ctx, input);
+    return components.map((component) => ctx.registry.packages[component].npm);
+}
+function normalizeList(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+async function runUpgradeCommand(ctx, input) {
+    const packageJson = await (0, readPackageJson_1.readPackageJson)(ctx.projectRoot);
+    const dependencies = packageJson.dependencies ?? {};
+    const devDependencies = packageJson.devDependencies ?? {};
+    const installedLattice = normalizeList([...Object.keys(dependencies), ...Object.keys(devDependencies)].filter((name) => name.startsWith("@lattice-ui/")));
+    let targets;
+    let missingRequested = [];
+    if (input.names.length === 0 && input.presets.length === 0) {
+        if (ctx.options.yes) {
+            targets = installedLattice;
+        }
+        else {
+            targets = await (0, prompt_1.promptMultiSelect)({ yes: ctx.options.yes }, "Select installed @lattice-ui/* packages to upgrade", installedLattice.map((name) => ({ label: name, value: name })), {
+                allowEmpty: false,
+                defaultIndices: installedLattice.map((_, index) => index),
+            });
+        }
+    }
+    else {
+        const requestedRegistryPackages = getSelectedRegistryPackages(ctx, input);
+        const installedSet = new Set(installedLattice);
+        targets = normalizeList(requestedRegistryPackages.filter((pkg) => installedSet.has(pkg)));
+        missingRequested = normalizeList(requestedRegistryPackages.filter((pkg) => !installedSet.has(pkg)));
+    }
+    const localLattice = (0, output_1.resolveLocalLatticeCommand)(ctx.pmName);
+    ctx.logger.section("Selecting");
+    ctx.logger.kv("Project", ctx.projectRoot);
+    let dependencySpecs = [];
+    let devDependencySpecs = [];
+    if (targets.length > 0) {
+        dependencySpecs = normalizeList(targets.filter((pkg) => dependencies[pkg] !== undefined).map((pkg) => `${pkg}@latest`));
+        devDependencySpecs = normalizeList(targets
+            .filter((pkg) => dependencies[pkg] === undefined && devDependencies[pkg] !== undefined)
+            .map((pkg) => `${pkg}@latest`));
+        if (dependencySpecs.length === 0 && devDependencySpecs.length === 0) {
+            throw (0, errors_1.usageError)("No upgradable dependency targets were found.");
+        }
+    }
+    ctx.logger.section("Planning");
+    const selectedSummary = (0, output_1.summarizeItems)(targets);
+    ctx.logger.kv("Selected", String(selectedSummary.total));
+    if (selectedSummary.total > 0) {
+        ctx.logger.list(selectedSummary.visible);
+        if (selectedSummary.hidden > 0) {
+            ctx.logger.step(`...and ${selectedSummary.hidden} more`);
+        }
+    }
+    if (missingRequested.length > 0) {
+        const missingSummary = (0, output_1.summarizeItems)(missingRequested);
+        ctx.logger.kv("Missing requested", String(missingSummary.total));
+        ctx.logger.list(missingSummary.visible);
+        if (missingSummary.hidden > 0) {
+            ctx.logger.step(`...and ${missingSummary.hidden} more`);
+        }
+    }
+    const dependencySummary = (0, output_1.summarizeItems)(dependencySpecs);
+    const devDependencySummary = (0, output_1.summarizeItems)(devDependencySpecs);
+    ctx.logger.kv("Dependency upgrades", String(dependencySummary.total));
+    if (dependencySummary.total > 0) {
+        ctx.logger.list(dependencySummary.visible);
+        if (dependencySummary.hidden > 0) {
+            ctx.logger.step(`...and ${dependencySummary.hidden} more`);
+        }
+    }
+    ctx.logger.kv("Dev dependency upgrades", String(devDependencySummary.total));
+    if (devDependencySummary.total > 0) {
+        ctx.logger.list(devDependencySummary.visible);
+        if (devDependencySummary.hidden > 0) {
+            ctx.logger.step(`...and ${devDependencySummary.hidden} more`);
+        }
+    }
+    if (ctx.options.dryRun) {
+        ctx.logger.section("Dry Run");
+        if (dependencySpecs.length === 0 && devDependencySpecs.length === 0) {
+            ctx.logger.step("[dry-run] No install actions required.");
+        }
+        else {
+            if (dependencySpecs.length > 0) {
+                ctx.logger.step(`[dry-run] ${ctx.pmName} add ${dependencySpecs.join(" ")}`);
+            }
+            if (devDependencySpecs.length > 0) {
+                ctx.logger.step(`[dry-run] ${ctx.pmName} add -D ${devDependencySpecs.join(" ")}`);
+            }
+        }
+        ctx.logger.step("No files were changed.");
+    }
+    else {
+        ctx.logger.section("Applying");
+        if (dependencySpecs.length === 0 && devDependencySpecs.length === 0) {
+            ctx.logger.step("No installation required.");
+        }
+        else {
+            if (dependencySpecs.length > 0) {
+                ctx.logger.step(`${ctx.pmName} add ${dependencySpecs.join(" ")}`);
+            }
+            if (devDependencySpecs.length > 0) {
+                ctx.logger.step(`${ctx.pmName} add -D ${devDependencySpecs.join(" ")}`);
+            }
+            const confirmed = await ctx.logger.confirm(`Upgrade ${targets.length} package(s) in ${ctx.projectRoot}?`);
+            if (!confirmed) {
+                ctx.logger.section("Result");
+                ctx.logger.warn("Upgrade cancelled.");
+                ctx.logger.section("Next Steps");
+                ctx.logger.step(`${localLattice} doctor`);
+                return;
+            }
+            const spinner = ctx.logger.spinner("Upgrading packages...");
+            if (dependencySpecs.length > 0) {
+                await ctx.pm.add(false, dependencySpecs, ctx.projectRoot);
+            }
+            if (devDependencySpecs.length > 0) {
+                await ctx.pm.add(true, devDependencySpecs, ctx.projectRoot);
+            }
+            spinner.succeed(`Upgraded ${targets.length} package(s).`);
+        }
+    }
+    if (targets.length === 0) {
+        ctx.logger.section("Result");
+        ctx.logger.warn("No installed @lattice-ui/* package matched upgrade selection.");
+        ctx.logger.section("Next Steps");
+        ctx.logger.step(`${localLattice} doctor`);
+        return;
+    }
+    ctx.logger.section("Result");
+    if (dependencySpecs.length === 0 && devDependencySpecs.length === 0) {
+        ctx.logger.success("No package upgrades were needed.");
+    }
+    else {
+        ctx.logger.success("Upgrade completed.");
+    }
+    ctx.logger.kv("Dependency upgrades", String(dependencySpecs.length));
+    ctx.logger.kv("Dev dependency upgrades", String(devDependencySpecs.length));
+    ctx.logger.section("Next Steps");
+    ctx.logger.step(`${localLattice} doctor`);
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,21 @@
+export declare enum ExitCode {
+    Success = 0,
+    Unexpected = 1,
+    Usage = 2,
+    ProjectNotFound = 3,
+    RegistryInvalid = 4,
+    PackageManagerFailed = 5
+}
+export type CliErrorKind = "Usage" | "Validation" | "ProjectNotFound" | "RegistryInvalid" | "PackageManagerFailed" | "Unexpected";
+export declare class CliError extends Error {
+    readonly kind: CliErrorKind;
+    readonly exitCode: ExitCode;
+    readonly cause?: unknown;
+    constructor(message: string, kind: CliErrorKind, exitCode: ExitCode, cause?: unknown);
+}
+export declare function usageError(message: string): CliError;
+export declare function validationError(message: string): CliError;
+export declare function projectNotFoundError(cwd: string): CliError;
+export declare function registryInvalidError(message: string, cause?: unknown): CliError;
+export declare function packageManagerFailedError(message: string, cause?: unknown): CliError;
+export declare function toCliError(error: unknown): CliError;

package/dist/core/errors.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = exports.ExitCode = void 0;
+exports.usageError = usageError;
+exports.validationError = validationError;
+exports.projectNotFoundError = projectNotFoundError;
+exports.registryInvalidError = registryInvalidError;
+exports.packageManagerFailedError = packageManagerFailedError;
+exports.toCliError = toCliError;
+var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["Success"] = 0] = "Success";
+    ExitCode[ExitCode["Unexpected"] = 1] = "Unexpected";
+    ExitCode[ExitCode["Usage"] = 2] = "Usage";
+    ExitCode[ExitCode["ProjectNotFound"] = 3] = "ProjectNotFound";
+    ExitCode[ExitCode["RegistryInvalid"] = 4] = "RegistryInvalid";
+    ExitCode[ExitCode["PackageManagerFailed"] = 5] = "PackageManagerFailed";
+})(ExitCode || (exports.ExitCode = ExitCode = {}));
+class CliError extends Error {
+    constructor(message, kind, exitCode, cause) {
+        super(message);
+        this.name = "CliError";
+        this.kind = kind;
+        this.exitCode = exitCode;
+        this.cause = cause;
+    }
+}
+exports.CliError = CliError;
+function usageError(message) {
+    return new CliError(message, "Usage", ExitCode.Usage);
+}
+function validationError(message) {
+    return new CliError(message, "Validation", ExitCode.Usage);
+}
+function projectNotFoundError(cwd) {
+    return new CliError(`Could not find package.json from "${cwd}".`, "ProjectNotFound", ExitCode.ProjectNotFound);
+}
+function registryInvalidError(message, cause) {
+    return new CliError(message, "RegistryInvalid", ExitCode.RegistryInvalid, cause);
+}
+function packageManagerFailedError(message, cause) {
+    return new CliError(message, "PackageManagerFailed", ExitCode.PackageManagerFailed, cause);
+}
+function toCliError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new CliError(error.message, "Unexpected", ExitCode.Unexpected, error);
+    }
+    return new CliError("Unexpected unknown error.", "Unexpected", ExitCode.Unexpected, error);
+}

package/dist/core/fs/copy.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "../logger";
+export interface CopyTemplateOptions {
+    dryRun: boolean;
+    logger?: Logger;
+    replacements?: Record<string, string>;
+    shouldIncludeFile?: (relativePath: string) => boolean;
+}
+export interface CopyTemplateReport {
+    created: string[];
+    merged: string[];
+    skipped: string[];
+}
+export declare function copyTemplateSafe(templateDir: string, targetDir: string, options: CopyTemplateOptions): Promise<CopyTemplateReport>;

package/dist/core/fs/copy.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyTemplateSafe = copyTemplateSafe;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const json_1 = require("./json");
+const patch_1 = require("./patch");
+function applyReplacements(content, replacements) {
+    if (!replacements) {
+        return content;
+    }
+    let next = content;
+    for (const [from, to] of Object.entries(replacements)) {
+        next = next.split(from).join(to);
+    }
+    return next;
+}
+function isJsonFile(filePath) {
+    return filePath.endsWith(".json");
+}
+function shouldPreserveJsonKeyOrder(relativePath) {
+    return relativePath === "package.json";
+}
+function resolveTargetRelativePath(relativePath) {
+    return relativePath.endsWith(".template") ? relativePath.slice(0, -".template".length) : relativePath;
+}
+async function pathExists(targetPath) {
+    try {
+        await node_fs_1.promises.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function walkFiles(root) {
+    const entries = await node_fs_1.promises.readdir(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const absolutePath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkFiles(absolutePath)));
+            continue;
+        }
+        files.push(absolutePath);
+    }
+    return files;
+}
+async function copyTemplateSafe(templateDir, targetDir, options) {
+    const files = await walkFiles(templateDir);
+    const report = {
+        created: [],
+        merged: [],
+        skipped: [],
+    };
+    for (const templateFilePath of files) {
+        const relativePath = resolveTargetRelativePath(path.relative(templateDir, templateFilePath));
+        if (options.shouldIncludeFile && !options.shouldIncludeFile(relativePath)) {
+            continue;
+        }
+        const targetFilePath = path.join(targetDir, relativePath);
+        const exists = await pathExists(targetFilePath);
+        if (!exists) {
+            if (!options.dryRun) {
+                const raw = await node_fs_1.promises.readFile(templateFilePath, "utf8");
+                const content = applyReplacements(raw, options.replacements);
+                await node_fs_1.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await node_fs_1.promises.writeFile(targetFilePath, content, "utf8");
+            }
+            report.created.push(relativePath);
+            continue;
+        }
+        if (!isJsonFile(relativePath)) {
+            report.skipped.push(relativePath);
+            continue;
+        }
+        const templateRaw = await node_fs_1.promises.readFile(templateFilePath, "utf8");
+        const templateJson = (0, json_1.parseJsonText)(applyReplacements(templateRaw, options.replacements));
+        const currentJson = await (0, json_1.readJsonFile)(targetFilePath);
+        const mergedJson = (0, patch_1.mergeMissing)(templateJson, currentJson);
+        const mergedText = JSON.stringify(mergedJson);
+        const currentText = JSON.stringify(currentJson);
+        if (mergedText === currentText) {
+            report.skipped.push(relativePath);
+            continue;
+        }
+        if (!options.dryRun) {
+            await (0, json_1.writeJsonFile)(targetFilePath, mergedJson, !shouldPreserveJsonKeyOrder(relativePath));
+        }
+        report.merged.push(relativePath);
+    }
+    if (options.logger?.verbose) {
+        options.logger.debug(`Template copy report: created=${report.created.length}, merged=${report.merged.length}, skipped=${report.skipped.length}`);
+    }
+    return report;
+}

package/dist/core/fs/json.d.ts

@@ -0,0 +1,3 @@
+export declare function parseJsonText<T = unknown>(content: string): T;
+export declare function readJsonFile<T = unknown>(filePath: string): Promise<T>;
+export declare function writeJsonFile(filePath: string, value: unknown, stable?: boolean): Promise<void>;

package/dist/core/fs/json.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonText = parseJsonText;
+exports.readJsonFile = readJsonFile;
+exports.writeJsonFile = writeJsonFile;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortValue(item));
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    return Object.fromEntries(entries.map(([key, item]) => [key, sortValue(item)]));
+}
+function stripJsonComments(content) {
+    let output = "";
+    let inString = false;
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const current = content[index];
+        const next = content[index + 1];
+        if (inLineComment) {
+            if (current === "\n") {
+                inLineComment = false;
+                output += current;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (current === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            output += current;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (current === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        output += current;
+        if (current === '"') {
+            inString = true;
+        }
+    }
+    return output;
+}
+function stripTrailingCommas(content) {
+    let output = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < content.length; index += 1) {
+        const current = content[index];
+        if (inString) {
+            output += current;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (current === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            output += current;
+            continue;
+        }
+        if (current !== ",") {
+            output += current;
+            continue;
+        }
+        let lookahead = index + 1;
+        while (lookahead < content.length && /\s/.test(content[lookahead])) {
+            lookahead += 1;
+        }
+        if (content[lookahead] === "}" || content[lookahead] === "]") {
+            continue;
+        }
+        output += current;
+    }
+    return output;
+}
+function parseJsonText(content) {
+    const withoutComments = stripJsonComments(content);
+    const normalized = stripTrailingCommas(withoutComments);
+    return JSON.parse(normalized);
+}
+async function readJsonFile(filePath) {
+    const content = await node_fs_1.promises.readFile(filePath, "utf8");
+    return parseJsonText(content);
+}
+async function writeJsonFile(filePath, value, stable = true) {
+    const normalized = stable ? sortValue(value) : value;
+    await node_fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await node_fs_1.promises.writeFile(filePath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+}

package/dist/core/fs/patch.d.ts

@@ -0,0 +1,16 @@
+export type DependencyField = "dependencies" | "devDependencies" | "peerDependencies" | "optionalDependencies";
+export type PackageJsonLike = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    [key: string]: unknown;
+};
+export declare function toPackageName(spec: string): string;
+export declare function getDependencyNames(manifest: PackageJsonLike): Set<string>;
+export declare function upsertDependencySpecs(manifest: PackageJsonLike, field: DependencyField, specs: string[]): {
+    changed: boolean;
+    added: string[];
+};
+export declare function mergeStringArraysUnique(existing: string[] | undefined, incoming: string[]): string[];
+export declare function mergeMissing(template: unknown, current: unknown): unknown;

package/dist/core/fs/patch.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPackageName = toPackageName;
+exports.getDependencyNames = getDependencyNames;
+exports.upsertDependencySpecs = upsertDependencySpecs;
+exports.mergeStringArraysUnique = mergeStringArraysUnique;
+exports.mergeMissing = mergeMissing;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function toPackageName(spec) {
+    if (spec.startsWith("@")) {
+        const slashIndex = spec.indexOf("/");
+        if (slashIndex < 0) {
+            return spec;
+        }
+        const versionIndex = spec.indexOf("@", slashIndex + 1);
+        return versionIndex < 0 ? spec : spec.slice(0, versionIndex);
+    }
+    const versionIndex = spec.indexOf("@");
+    return versionIndex < 0 ? spec : spec.slice(0, versionIndex);
+}
+function getDependencyNames(manifest) {
+    const names = new Set();
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+        const dependencies = manifest[field];
+        if (!dependencies || typeof dependencies !== "object") {
+            continue;
+        }
+        for (const name of Object.keys(dependencies)) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function upsertDependencySpecs(manifest, field, specs) {
+    const dependencyMap = { ...(manifest[field] ?? {}) };
+    let changed = false;
+    const added = [];
+    for (const spec of specs) {
+        const packageName = toPackageName(spec);
+        if (!packageName) {
+            continue;
+        }
+        if (dependencyMap[packageName] !== spec) {
+            dependencyMap[packageName] = spec;
+            changed = true;
+        }
+        if (!added.includes(packageName)) {
+            added.push(packageName);
+        }
+    }
+    manifest[field] = sortRecord(dependencyMap);
+    return { changed, added };
+}
+function mergeStringArraysUnique(existing, incoming) {
+    const out = [...(existing ?? [])];
+    for (const value of incoming) {
+        if (!out.includes(value)) {
+            out.push(value);
+        }
+    }
+    return out;
+}
+function mergeMissing(template, current) {
+    if (current === undefined) {
+        return template;
+    }
+    if (isStringArray(template) && isStringArray(current)) {
+        return mergeStringArraysUnique(current, template);
+    }
+    if (Array.isArray(template) || Array.isArray(current)) {
+        return current;
+    }
+    if (!isPlainObject(template) || !isPlainObject(current)) {
+        return current;
+    }
+    const out = { ...current };
+    for (const [key, templateValue] of Object.entries(template)) {
+        out[key] = mergeMissing(templateValue, current[key]);
+    }
+    return out;
+}