tegami 1.1.3 → 1.2.1

package/dist/version-request-DlLpLLK3.js

@@ -1,445 +0,0 @@
-import { r as formatNpmDistTag } from "./semver-EKJ8yK5U.js";
-import { n as execFailure, o as isCI } from "./error-BhMYq9iW.js";
-import { t as _accessExpressionAsString } from "./_accessExpressionAsString-QhbUZzwv.js";
-import { n as _validateReport, t as _createStandardSchema } from "./_createStandardSchema-BGQyz-uA.js";
-import { i as parsePublishLock } from "./draft-CzUiQasJ.js";
-import { readFile, writeFile } from "node:fs/promises";
-import { x } from "tinyexec";
-//#region src/utils/version-request.ts
-const validatePublishGroupStore = (() => {
-	const _io0 = (input) => Array.isArray(input.active) && input.active.every((elem) => "object" === typeof elem && null !== elem && _io1(elem)) && Array.isArray(input.pending) && input.pending.every((elem) => "object" === typeof elem && null !== elem && _io1(elem)) && "object" === typeof input.versions && null !== input.versions && false === Array.isArray(input.versions) && _io2(input.versions);
-	const _io1 = (input) => "string" === typeof input.title && "string" === typeof input.branch && Array.isArray(input.packages) && input.packages.every((elem) => "string" === typeof elem);
-	const _io2 = (input) => Object.keys(input).every((key) => {
-		const value = input[key];
-		if (void 0 === value) return true;
-		return "string" === typeof value;
-	});
-	const _vo0 = (input, _path, _exceptionable = true) => [
-		(Array.isArray(input.active) || _report(_exceptionable, {
-			path: _path + ".active",
-			expected: "Array<PublishGroup>",
-			value: input.active
-		})) && input.active.map((elem, _index4) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-			path: _path + ".active[" + _index4 + "]",
-			expected: "PublishGroup",
-			value: elem
-		})) && _vo1(elem, _path + ".active[" + _index4 + "]", _exceptionable) || _report(_exceptionable, {
-			path: _path + ".active[" + _index4 + "]",
-			expected: "PublishGroup",
-			value: elem
-		})).every((flag) => flag) || _report(_exceptionable, {
-			path: _path + ".active",
-			expected: "Array<PublishGroup>",
-			value: input.active
-		}),
-		(Array.isArray(input.pending) || _report(_exceptionable, {
-			path: _path + ".pending",
-			expected: "Array<PublishGroup>",
-			value: input.pending
-		})) && input.pending.map((elem, _index5) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-			path: _path + ".pending[" + _index5 + "]",
-			expected: "PublishGroup",
-			value: elem
-		})) && _vo1(elem, _path + ".pending[" + _index5 + "]", _exceptionable) || _report(_exceptionable, {
-			path: _path + ".pending[" + _index5 + "]",
-			expected: "PublishGroup",
-			value: elem
-		})).every((flag) => flag) || _report(_exceptionable, {
-			path: _path + ".pending",
-			expected: "Array<PublishGroup>",
-			value: input.pending
-		}),
-		("object" === typeof input.versions && null !== input.versions && false === Array.isArray(input.versions) || _report(_exceptionable, {
-			path: _path + ".versions",
-			expected: "Record<string, string>",
-			value: input.versions
-		})) && _vo2(input.versions, _path + ".versions", _exceptionable) || _report(_exceptionable, {
-			path: _path + ".versions",
-			expected: "Record<string, string>",
-			value: input.versions
-		})
-	].every((flag) => flag);
-	const _vo1 = (input, _path, _exceptionable = true) => [
-		"string" === typeof input.title || _report(_exceptionable, {
-			path: _path + ".title",
-			expected: "string",
-			value: input.title
-		}),
-		"string" === typeof input.branch || _report(_exceptionable, {
-			path: _path + ".branch",
-			expected: "string",
-			value: input.branch
-		}),
-		(Array.isArray(input.packages) || _report(_exceptionable, {
-			path: _path + ".packages",
-			expected: "Array<string>",
-			value: input.packages
-		})) && input.packages.map((elem, _index6) => "string" === typeof elem || _report(_exceptionable, {
-			path: _path + ".packages[" + _index6 + "]",
-			expected: "string",
-			value: elem
-		})).every((flag) => flag) || _report(_exceptionable, {
-			path: _path + ".packages",
-			expected: "Array<string>",
-			value: input.packages
-		})
-	].every((flag) => flag);
-	const _vo2 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
-		const value = input[key];
-		if (void 0 === value) return true;
-		return "string" === typeof value || _report(_exceptionable, {
-			path: _path + _accessExpressionAsString(key),
-			expected: "string",
-			value
-		});
-	}).every((flag) => flag)].every((flag) => flag);
-	const __is = (input) => "object" === typeof input && null !== input && _io0(input);
-	let errors;
-	let _report;
-	return _createStandardSchema((input) => {
-		if (false === __is(input)) {
-			errors = [];
-			_report = _validateReport(errors);
-			((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-				path: _path + "",
-				expected: "PublishGroupStore",
-				value: input
-			})) && _vo0(input, _path + "", true) || _report(true, {
-				path: _path + "",
-				expected: "PublishGroupStore",
-				value: input
-			}))(input, "$input", true);
-			const success = 0 === errors.length;
-			return success ? {
-				success,
-				data: input
-			} : {
-				success,
-				errors,
-				data: input
-			};
-		}
-		return {
-			success: true,
-			data: input
-		};
-	});
-})();
-function onVersionRequest(provider) {
-	const namespace = `${provider.name}:publish-group`;
-	/** package id -> version before applying the CLI draft */
-	const snapshots = /* @__PURE__ */ new Map();
-	/** publish group state restored from the lock, publish-time only */
-	let store;
-	function resolveConfig() {
-		if (provider.options === false) return;
-		const { forceCreate = false, branch = "tegami/version-packages", base = "main", groups, create } = provider.options ?? {};
-		return {
-			forceCreate,
-			branch,
-			base,
-			groups,
-			create
-		};
-	}
-	async function createDraftRequest(context, config, draft, versions, group) {
-		const custom = await config.create?.call(context, {
-			draft,
-			publishGroup: group?.packages
-		});
-		return {
-			title: custom?.title ?? group?.title ?? "Version Packages",
-			body: custom?.body ?? renderRequestBody(draftRequestItems(context, draft, versions, group), provider.summary)
-		};
-	}
-	async function upsertRequest(context, request) {
-		const handle = await provider.find(context, {
-			head: request.head,
-			base: request.base
-		});
-		if (handle !== void 0) await provider.update(context, handle, request);
-		else await provider.create(context, request);
-	}
-	return {
-		/** snapshot package versions, hook into `initCliDraft` */
-		initCliDraft() {
-			for (const pkg of this.graph.getPackages()) snapshots.set(pkg.id, pkg.version);
-		},
-		/** commit & push version branches, then upsert their requests, hook into `applyCliDraft` */
-		async applyCliDraft(draft) {
-			const config = resolveConfig();
-			if (!config || !provider.enabled(this)) return;
-			if (!(config.forceCreate || isCI()) || !await hasGitChanges(this.cwd)) return;
-			/** package id -> version before the bump */
-			const versions = {};
-			for (const id of draft.getPackageDrafts().keys()) {
-				const pkg = this.graph.get(id);
-				const original = snapshots.get(id);
-				if (!pkg?.version || !original || original === pkg.version) continue;
-				versions[id] = original;
-			}
-			const groups = resolvePublishGroups(this, config.branch, config.groups, versions);
-			if (groups.length === 0) {
-				const request = await createDraftRequest(this, config, draft, versions);
-				await createVersionCommit(this.cwd, request.title);
-				await pushBranch(this.cwd, config.branch);
-				await upsertRequest(this, {
-					...request,
-					head: config.branch,
-					base: config.base
-				});
-				return;
-			}
-			const requests = [];
-			for (const group of groups) {
-				const request = await createDraftRequest(this, config, draft, versions, group);
-				group.title = request.title;
-				requests.push(request);
-			}
-			await createVersionCommit(this.cwd, "Version Packages");
-			const versionCommit = await run(this.cwd, ["rev-parse", "HEAD"], "Failed to resolve the version commit.");
-			if (!versionCommit) throw new Error("Failed to resolve the version commit.");
-			/** lock content of the version commit, without publish groups */
-			const lockContent = await readFile(this.lockPath, "utf8");
-			for (let i = 0; i < groups.length; i++) {
-				const group = groups[i];
-				const request = requests[i];
-				if (i > 0) await run(this.cwd, [
-					"checkout",
-					"--detach",
-					versionCommit
-				], "Failed to check out the version commit.");
-				const lock = parsePublishLock(lockContent);
-				lock.write(namespace, {
-					active: [group],
-					pending: groups.filter((other) => other !== group),
-					versions
-				});
-				await writeFile(this.lockPath, lock.serialize());
-				await commitChanges(this.cwd, request.title);
-				await pushBranch(this.cwd, group.branch);
-				await upsertRequest(this, {
-					...request,
-					head: group.branch,
-					base: config.base
-				});
-			}
-		},
-		/** restore publish groups from the lock into the plan, hook into `initPublishPlan` */
-		initPublishPlan({ lock, plan }) {
-			store = void 0;
-			let data;
-			const entries = [];
-			while ((data = lock.read(namespace)) !== void 0) {
-				const validated = validatePublishGroupStore(data);
-				if (validated.success) entries.push(validated.data);
-			}
-			if (entries.length === 0) return;
-			const merged = {
-				active: [],
-				pending: [],
-				versions: {}
-			};
-			const seen = /* @__PURE__ */ new Set();
-			for (const entry of entries) {
-				Object.assign(merged.versions, entry.versions);
-				for (const group of entry.active) {
-					if (seen.has(group.branch)) continue;
-					seen.add(group.branch);
-					merged.active.push(group);
-				}
-			}
-			for (const entry of entries) for (const group of entry.pending) {
-				if (seen.has(group.branch)) continue;
-				seen.add(group.branch);
-				merged.pending.push(group);
-			}
-			store = merged;
-			const packages = new Set(plan.options.packages);
-			for (const group of merged.active) for (const name of group.packages) packages.add(name);
-			if (packages.size > 0) plan.options = {
-				...plan.options,
-				packages: Array.from(packages)
-			};
-		},
-		/** report `pending` while publish groups are waiting for their request, hook into `resolvePlanStatus` */
-		resolvePlanStatus() {
-			if (store && store.pending.length > 0) return "pending";
-		},
-		/** re-sync the version requests of pending publish groups, hook into `beforePublishAll` */
-		async beforePublishAll({ plan }) {
-			if (!store || store.pending.length === 0 || plan.options.dryRun) return;
-			const config = resolveConfig();
-			if (!config || !provider.enabled(this)) return;
-			const head = await run(this.cwd, ["rev-parse", "HEAD"], "Failed to resolve the current commit.");
-			const ref = await run(this.cwd, [
-				"rev-parse",
-				"--abbrev-ref",
-				"HEAD"
-			], "Failed to resolve the current branch.");
-			const lockContent = await readFile(this.lockPath, "utf8");
-			try {
-				for (const group of store.pending) {
-					const lock = parsePublishLock(lockContent);
-					while (lock.read(namespace) !== void 0);
-					lock.write(namespace, {
-						active: [...store.active, group],
-						pending: store.pending.filter((other) => other !== group),
-						versions: store.versions
-					});
-					await run(this.cwd, [
-						"checkout",
-						"--detach",
-						head
-					], "Failed to check out the current commit.");
-					await writeFile(this.lockPath, lock.serialize());
-					await commitChanges(this.cwd, group.title);
-					await pushBranch(this.cwd, group.branch);
-					await upsertRequest(this, {
-						title: group.title,
-						body: renderRequestBody(planRequestItems(this, plan, store.versions, group), provider.summary),
-						head: group.branch,
-						base: config.base
-					});
-				}
-			} finally {
-				await run(this.cwd, ["checkout", ref === "HEAD" ? head : ref], "Failed to restore the original checkout.");
-			}
-		}
-	};
-}
-function resolvePublishGroups(context, branch, groups, versions) {
-	if (!groups?.length) return [];
-	const out = [];
-	const matched = /* @__PURE__ */ new Set();
-	for (const entry of groups) {
-		const members = Array.isArray(entry) ? entry : [entry];
-		let hasMatched = false;
-		for (const name of members) for (const pkg of context.graph.getByName(name)) if (pkg.id in versions && !matched.has(pkg.id)) {
-			hasMatched = true;
-			matched.add(pkg.id);
-		}
-		if (!hasMatched) continue;
-		const slug = members.map(branchSlug).filter(Boolean).join("-") || "group";
-		out.push({
-			title: `Release ${members.join(", ")}`,
-			branch: `${branch}/${slug}`,
-			packages: members
-		});
-	}
-	const unlisted = Object.keys(versions).filter((id) => !matched.has(id));
-	if (unlisted.length > 0) out.push({
-		title: "Release unlisted packages",
-		branch: `${branch}/unlisted`,
-		packages: unlisted
-	});
-	return out;
-}
-function branchSlug(name) {
-	return name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function resolveMembers(context, group) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const name of group.packages) for (const pkg of context.graph.getByName(name)) ids.add(pkg.id);
-	return ids;
-}
-function draftRequestItems(context, draft, versions, group) {
-	const members = group ? resolveMembers(context, group) : void 0;
-	const items = [];
-	for (const [id, packageDraft] of draft.getPackageDrafts()) {
-		if (members && !members.has(id)) continue;
-		const pkg = context.graph.get(id);
-		if (!pkg) continue;
-		items.push({
-			pkg,
-			from: versions[id],
-			changelogs: packageDraft.changelogs ?? [],
-			distTag: packageDraft.npm?.distTag
-		});
-	}
-	return items;
-}
-function planRequestItems(context, plan, versions, group) {
-	const items = [];
-	for (const id of resolveMembers(context, group)) {
-		const pkg = context.graph.get(id);
-		const packagePlan = plan.packages.get(id);
-		if (!pkg || !packagePlan) continue;
-		items.push({
-			pkg,
-			from: versions[id],
-			changelogs: packagePlan.changelogs,
-			distTag: packagePlan.npm?.distTag
-		});
-	}
-	return items;
-}
-function renderRequestBody(items, summary) {
-	const packageLines = [];
-	const changesets = /* @__PURE__ */ new Map();
-	for (const { pkg, from, changelogs, distTag } of items) {
-		for (const entry of changelogs) {
-			const list = changesets.get(entry);
-			if (list) list.push(pkg);
-			else changesets.set(entry, [pkg]);
-		}
-		if (!from || from === pkg.version) continue;
-		packageLines.push(`| \`${pkg.name}\` | \`${from}\` | \`${pkg.version}\`${formatNpmDistTag(distTag)} |`);
-	}
-	const changelogLines = [];
-	for (const [entry, linkedPackages] of changesets) {
-		changelogLines.push(`### ${entry.subject ?? `\`${entry.filename}\``}`, "");
-		changelogLines.push("<details>", `<summary>Show Bumped Packages (${linkedPackages.length})</summary>`, "", ...linkedPackages.map((pkg) => `- \`${pkg.id}\``), "", "</details>", "");
-		for (const section of entry.sections) {
-			changelogLines.push(`#### ${section.title}`, "");
-			if (section.content) changelogLines.push(section.content);
-		}
-	}
-	const sections = [
-		"## Summary",
-		"",
-		summary,
-		""
-	];
-	if (packageLines.length > 0) sections.push("| Package | From | To |", "| --- | --- | --- |", ...packageLines);
-	if (changelogLines.length > 0) sections.push("", "## Changelogs", ...changelogLines);
-	sections.push("");
-	return sections.join("\n");
-}
-async function run(cwd, args, message) {
-	const result = await x("git", args, { nodeOptions: { cwd } });
-	if (result.exitCode !== 0) throw execFailure(message, result);
-	return result.stdout.trim();
-}
-async function hasGitChanges(cwd) {
-	return (await run(cwd, ["status", "--porcelain"], "Failed to check git status.")).length > 0;
-}
-async function commitChanges(cwd, title) {
-	await run(cwd, ["add", "-A"], "Failed to stage version changes.");
-	await run(cwd, [
-		"commit",
-		"-m",
-		title
-	], "Failed to commit version changes.");
-}
-/** commit the working tree changes onto a detached HEAD */
-async function createVersionCommit(cwd, title) {
-	await run(cwd, ["checkout", "--detach"], "Failed to detach HEAD for version branches.");
-	await commitChanges(cwd, title);
-}
-async function pushBranch(cwd, branch) {
-	await run(cwd, [
-		"checkout",
-		"-B",
-		branch
-	], "Failed to create the version branch.");
-	await run(cwd, [
-		"push",
-		"--force",
-		"-u",
-		"origin",
-		branch
-	], "Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.");
-}
-//#endregion
-export { onVersionRequest as t };