tegami 1.1.1 → 1.1.3

package/dist/version-request-DlLpLLK3.js

@@ -0,0 +1,445 @@
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tegami",
-  "version": "1.1.1",
-  "description": "Utility for package versioning & publish",
+  "version": "1.1.3",
+  "description": "A tool to manage changelogs, versioning, and publishing in monorepo",
   "license": "MIT",
   "author": "Fuma Nama",
   "repository": {

package/dist/version-request-oxy16TJ1.js

@@ -1,71 +0,0 @@
-import { r as formatNpmDistTag } from "./semver-EKJ8yK5U.js";
-import { n as execFailure } from "./error-BhMYq9iW.js";
-import { x } from "tinyexec";
-//#region src/utils/version-request.ts
-async function hasGitChanges(cwd) {
-	const result = await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } });
-	if (result.exitCode !== 0) throw execFailure("Failed to check git status.", result);
-	return result.stdout.trim().length > 0;
-}
-async function commitVersionBranchChanges(cwd, branch, title) {
-	const gitOptions = { nodeOptions: { cwd } };
-	let result = await x("git", [
-		"checkout",
-		"-B",
-		branch
-	], gitOptions);
-	if (result.exitCode !== 0) throw execFailure("Failed to create the version branch.", result);
-	result = await x("git", ["add", "-A"], gitOptions);
-	if (result.exitCode !== 0) throw execFailure("Failed to stage version changes.", result);
-	result = await x("git", [
-		"commit",
-		"-m",
-		title
-	], gitOptions);
-	if (result.exitCode !== 0) throw execFailure("Failed to commit version changes.", result);
-	result = await x("git", [
-		"push",
-		"--force",
-		"-u",
-		"origin",
-		branch
-	], gitOptions);
-	if (result.exitCode !== 0) throw execFailure("Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.", result);
-}
-function createVersionRequestBody(draft, context, snapshots, summary) {
-	const packageLines = [];
-	const changesets = /* @__PURE__ */ new Map();
-	for (const [id, packageDraft] of draft.getPackageDrafts()) {
-		const pkg = context.graph.get(id);
-		if (!pkg) continue;
-		for (const entry of packageDraft.changelogs ?? []) {
-			const list = changesets.get(entry);
-			if (list) list.push(pkg);
-			else changesets.set(entry, [pkg]);
-		}
-		const originalVersion = snapshots.get(pkg.id);
-		if (!originalVersion || originalVersion === pkg.version) continue;
-		packageLines.push(`| \`${pkg.name}\` | \`${originalVersion}\` | \`${pkg.version}\`${formatNpmDistTag(packageDraft.npm?.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");
-}
-//#endregion
-export { createVersionRequestBody as n, hasGitChanges as r, commitVersionBranchChanges as t };

package/dist/{draft-DsxZOCOb.js → draft-CzUiQasJ.js}

@@ -3,8 +3,8 @@ import { r as handlePluginError } 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 { n as validateChangelogFrontmatter, t as renderChangelog } from "./shared-C_iSTp_s.js";
-import { t as _assertGuard } from "./_assertGuard-BBn2NbSz.js";
 import { simpleGenerator } from "./generators/simple.js";
+import { t as _assertGuard } from "./_assertGuard-BBn2NbSz.js";
 import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { basename, dirname, join } from "node:path";
 import * as semver$1 from "semver";