tegami 1.1.3 → 1.2.1

package/dist/plugins/gitlab.d.ts

@@ -1,5 +1,6 @@
-import { A as WorkspacePackage, b as TegamiContext, j as Draft, s as TegamiPlugin, t as Awaitable, v as PublishPlan } from "../types-DEyZ2r-2.js";
+import { A as WorkspacePackage, b as TegamiContext, s as TegamiPlugin, t as Awaitable, v as PublishPlan } from "../types-BbwOrNZ2.js";
 import { GitPluginOptions } from "./git.js";
+import { t as VersionRequestOptions } from "../version-request-BQwP7EWa.js";
 
 //#region src/plugins/gitlab.d.ts
 interface GitlabRelease {
@@ -8,51 +9,6 @@ interface GitlabRelease {
   /** Release notes */
   notes?: string;
 }
-interface VersionMergeRequest {
-  /** Merge request title. */
-  title?: string;
-  /** Merge request body. */
-  body?: string;
-}
-interface VersionMergeRequestOptions {
-  /**
-   * Create the MR even outside of CI.
-   *
-   * @default false
-   */
-  forceCreate?: boolean;
-  /**
-   * Merge request branch. Publish group MRs are created under `<branch>/`.
-   *
-   * @default "tegami/version-packages"
-   */
-  branch?: string;
-  /**
-   * Merge request base branch.
-   *
-   * @default "main"
-   */
-  base?: string;
-  /**
-   * Publish groups to split into separate version MRs, each entry is a package (or a list of
-   * packages) to version & publish together. Packages not covered by any group are collected
-   * into an extra "unlisted packages" MR.
-   *
-   * Merging a group MR publishes only its members, the remaining MRs are re-synced on every
-   * publish run until all of them are merged & published.
-   */
-  groups?: (string | string[])[];
-  /**
-   * Override details for a version MR.
-   *
-   * Only called at version-time: publish group MRs re-synced at publish-time keep the stored
-   * title and use a default body.
-   */
-  create?: (this: TegamiContext, opts: {
-    draft: Draft;
-    publishGroup?: string[];
-  }) => Awaitable<VersionMergeRequest>;
-}
 /** Options for creating GitLab releases after a successful publish. */
 interface GitLabPluginOptions extends GitPluginOptions {
   /** GitLab repository. */
@@ -91,7 +47,7 @@ interface GitLabPluginOptions extends GitPluginOptions {
    *
    * Defaults to enabled in CI and disabled locally.
    */
-  versionMr?: VersionMergeRequestOptions | false;
+  versionMr?: VersionRequestOptions | false;
 }
 /** Create GitLab releases for successfully published packages after the whole plan succeeds. */
 declare function gitlab(options?: GitLabPluginOptions): TegamiPlugin[];

package/dist/plugins/gitlab.js

@@ -1,9 +1,9 @@
 import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-EKJ8yK5U.js";
-import { t as changelogFilename } from "../generate-Bg86OJP4.js";
-import { a as cached, n as execFailure, o as isCI, s as joinPath } from "../error-BhMYq9iW.js";
-import { o as readChangelogEntries, t as createDraft } from "../draft-CzUiQasJ.js";
+import { t as changelogFilename } from "../generate-Cnd8RiKO.js";
+import { c as joinPath, n as execFailure, o as cached, r as fetchFailure, s as isCI } from "../error-CAsrGb6e.js";
+import { a as createDraft, l as readChangelogEntries } from "../publish-Bt3e1RPs.js";
 import { git } from "./git.js";
-import { t as onVersionRequest } from "../version-request-DlLpLLK3.js";
+import { t as onVersionRequest } from "../version-request-DvWVAYj2.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";
@@ -31,12 +31,12 @@ async function releaseExistsByTag(repo, tag, options = {}) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
 	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/releases/${encodeURIComponent(tag)}`, { method: "HEAD" });
 	if (response.status === 404) return false;
-	if (!response.ok) throw new Error(`Failed to get GitLab release for ${tag}.`);
+	if (!response.ok) throw await fetchFailure(`Failed to get GitLab release for ${tag}`, response);
 	return true;
 }
 async function createRelease(repo, options) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
-	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/releases`, {
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/releases`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({
@@ -44,7 +44,8 @@ async function createRelease(repo, options) {
 			name: options.title,
 			description: options.notes
 		})
-	})).ok) throw new Error(`Failed to create GitLab release for ${options.tag}.`);
+	});
+	if (!response.ok) throw await fetchFailure(`Failed to create GitLab release for ${options.tag}`, response);
 }
 async function findOpenMergeRequest(repo, options) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
@@ -54,12 +55,12 @@ async function findOpenMergeRequest(repo, options) {
 	});
 	if (options.base) params.set("target_branch", options.base);
 	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests?${params}`);
-	if (!response.ok) throw new Error("Failed to check for an existing version merge request.");
+	if (!response.ok) throw await fetchFailure("Failed to check for an existing version merge request", response);
 	return (await response.json())[0]?.iid;
 }
 async function updateMergeRequest(repo, number, options) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
-	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${number}`, {
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${number}`, {
 		method: "PUT",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({
@@ -67,11 +68,12 @@ async function updateMergeRequest(repo, number, options) {
 			description: options.body,
 			target_branch: options.base
 		})
-	})).ok) throw new Error("Failed to update the version merge request.");
+	});
+	if (!response.ok) throw await fetchFailure("Failed to update the version merge request", response);
 }
 async function createMergeRequest(repo, options) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
-	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests`, {
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({
@@ -80,12 +82,13 @@ async function createMergeRequest(repo, options) {
 			source_branch: options.head,
 			target_branch: options.base
 		})
-	})).ok) throw new Error("Failed to create the version merge request.");
+	});
+	if (!response.ok) throw await fetchFailure("Failed to create the version merge request", response);
 }
 async function getMergeRequest(repo, number, options = {}) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
 	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${number}`);
-	if (!response.ok) throw new Error(`Failed to resolve merge request !${number}.`);
+	if (!response.ok) throw await fetchFailure(`Failed to resolve merge request !${number}`, response);
 	const data = await response.json();
 	let sourceProjectPath;
 	if (data.source_project_id !== void 0) {
@@ -102,7 +105,7 @@ async function getMergeRequest(repo, number, options = {}) {
 async function listMergeRequestsForCommit(repo, commitSha, options = {}) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
 	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/repository/commits/${commitSha}/merge_requests`);
-	if (!response.ok) throw new Error(`Failed to list merge requests for commit ${commitSha.slice(0, 7)}.`);
+	if (!response.ok) throw await fetchFailure(`Failed to list merge requests for commit ${commitSha.slice(0, 7)}`, response);
 	return (await response.json()).map((mergeRequest) => ({
 		number: mergeRequest.iid,
 		title: mergeRequest.title,
@@ -114,7 +117,7 @@ async function findMergeRequestCommentByPrefix(repo, mergeRequestNumber, prefix,
 	let page = 1;
 	while (true) {
 		const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes?per_page=100&page=${page}`);
-		if (!response.ok) throw new Error("Failed to list merge request comments.");
+		if (!response.ok) throw await fetchFailure("Failed to list merge request comments", response);
 		const batch = await response.json();
 		if (batch.length === 0) break;
 		const comment = batch.find((comment) => comment.body.startsWith(prefix));
@@ -125,19 +128,21 @@ async function findMergeRequestCommentByPrefix(repo, mergeRequestNumber, prefix,
 }
 async function updateMergeRequestComment(repo, mergeRequestNumber, commentId, body, options = {}) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
-	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes/${commentId}`, {
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes/${commentId}`, {
 		method: "PUT",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({ body })
-	})).ok) throw new Error("Failed to update merge request comment.");
+	});
+	if (!response.ok) throw await fetchFailure("Failed to update merge request comment", response);
 }
 async function createMergeRequestComment(repo, mergeRequestNumber, body, options = {}) {
 	const { encodedProjectPath } = parseGitLabRepo(repo);
-	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes`, {
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({ body })
-	})).ok) throw new Error("Failed to create merge request comment.");
+	});
+	if (!response.ok) throw await fetchFailure("Failed to create merge request comment", response);
 }
 //#endregion
 //#region src/plugins/gitlab/cli.ts
@@ -311,38 +316,36 @@ function gitlab(options = {}) {
 	}
 	const versionRequests = onVersionRequest({
 		name: "gitlab",
-		summary: "Merge this MR to publish the versioned packages.",
 		options: options.versionMr,
-		enabled(context) {
+		canCreate(context) {
 			const { repo, token } = context.gitlab ?? {};
 			return Boolean(repo && token);
 		},
-		find(context, { head, base }) {
-			return findOpenMergeRequest(context.gitlab.repo, {
-				head,
-				base,
-				...gitLabApiOptions(context.gitlab)
+		async upsert(context, request, update) {
+			const repo = context.gitlab.repo;
+			const api = gitLabApiOptions(context.gitlab);
+			const openMr = await findOpenMergeRequest(repo, {
+				head: request.head,
+				base: request.base,
+				...api
 			});
-		},
-		create(context, request) {
-			return createMergeRequest(context.gitlab.repo, {
+			if (openMr === void 0) await createMergeRequest(repo, {
 				title: request.title,
 				body: request.body,
 				head: request.head,
 				base: request.base,
-				...gitLabApiOptions(context.gitlab)
+				...api
 			});
-		},
-		update(context, number, request) {
-			return updateMergeRequest(context.gitlab.repo, number, {
+			else if (update) await updateMergeRequest(repo, openMr, {
 				title: request.title,
 				body: request.body,
 				base: request.base,
-				...gitLabApiOptions(context.gitlab)
+				...api
 			});
 		}
 	});
-	return [git(options), {
+	const plugin = {
+		...versionRequests,
 		name: "gitlab",
 		init() {
 			this.gitlab = {
@@ -353,7 +356,7 @@ function gitlab(options = {}) {
 			};
 		},
 		async resolvePlanStatus({ plan }) {
-			if (versionRequests.resolvePlanStatus() === "pending") return "pending";
+			if (versionRequests.resolvePlanStatus.call(this, { plan }) === "pending") return "pending";
 			const { repo, token } = this.gitlab;
 			if (!repo || !token || releaseOptions === false) return;
 			const requiredTags = /* @__PURE__ */ new Set();
@@ -425,20 +428,9 @@ function gitlab(options = {}) {
 				gitlabRemoteUrl(repo, token, webUrl)
 			], { nodeOptions: { cwd: this.cwd } });
 			if (result.exitCode !== 0) throw execFailure("Failed to configure git remote for GitLab CI.", result);
-		},
-		initCliDraft() {
-			versionRequests.initCliDraft.call(this);
-		},
-		applyCliDraft(draft) {
-			return versionRequests.applyCliDraft.call(this, draft);
-		},
-		initPublishPlan(opts) {
-			versionRequests.initPublishPlan.call(this, opts);
-		},
-		beforePublishAll(opts) {
-			return versionRequests.beforePublishAll.call(this, opts);
 		}
-	}];
+	};
+	return [git(options), plugin];
 }
 function createChangelogRenderer(context) {
 	const { repo, webUrl } = context.gitlab;

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { A as WorkspacePackage, P as BumpType, s as TegamiPlugin } from "../types-DEyZ2r-2.js";
+import { A as WorkspacePackage, P as BumpType, s as TegamiPlugin } from "../types-BbwOrNZ2.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/plugins/go.js

@@ -1,4 +1,4 @@
-import { i as isNodeError, n as execFailure } from "../error-BhMYq9iW.js";
+import { a as isNodeError, n as execFailure, r as fetchFailure } from "../error-CAsrGb6e.js";
 import { n as _validateReport, t as _createStandardSchema } from "../_createStandardSchema-BGQyz-uA.js";
 import { n as WorkspacePackage } from "../graph-BmXTJZxx.js";
 import { relative, resolve } from "node:path";
@@ -524,7 +524,7 @@ async function isModulePublished(module, version) {
 	const response = await fetch(`https://proxy.golang.org/${encodeURIComponent(module)}/@v/${formatted}.info`);
 	if (response.status === 200) return true;
 	if (response.status === 404) return false;
-	throw new Error(`Unable to validate ${module}@${formatted} against proxy.golang.org: ${await response.text()}`);
+	throw await fetchFailure(`Unable to validate ${module}@${formatted} against proxy.golang.org`, response);
 }
 //#endregion
 export { GoPackage, go };

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { C as NpmPackage, S as NpmGraph, l as NpmPluginOptions, u as npm, x as DependencySpec } from "../types-DEyZ2r-2.js";
+import { C as NpmPackage, S as NpmGraph, l as NpmPluginOptions, u as npm, x as DependencySpec } from "../types-BbwOrNZ2.js";
 export { type DependencySpec, type NpmGraph, NpmPackage, NpmPluginOptions, npm };

package/dist/providers/npm.js

@@ -1,2 +1,2 @@
-import { n as NpmPackage, t as npm } from "../npm-CaBYeOeV.js";
+import { n as NpmPackage, t as npm } from "../npm-4iA03RvC.js";
 export { NpmPackage, npm };

package/dist/{draft-CzUiQasJ.js → publish-Bt3e1RPs.js}

@@ -1,11 +1,11 @@
 import { a as maxBump } from "./semver-EKJ8yK5U.js";
-import { r as handlePluginError } from "./error-BhMYq9iW.js";
+import { i as handlePluginError, l as somePromise } from "./error-CAsrGb6e.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 { simpleGenerator } from "./generators/simple.js";
 import { t as _assertGuard } from "./_assertGuard-BBn2NbSz.js";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import fs, { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { basename, dirname, join } from "node:path";
 import * as semver$1 from "semver";
 import { parse as parse$1, stringify } from "yaml";
@@ -178,10 +178,14 @@ function headingToBump(depth) {
 /**
 * the data structure of `publish-lock.yaml` file.
 */
-var PublishLock = class {
+var PublishLock = class PublishLock {
+	/** namespace -> data array */
 	data;
-	constructor(data = /* @__PURE__ */ new Map()) {
-		this.data = data;
+	constructor(input = /* @__PURE__ */ new Map()) {
+		if (input instanceof PublishLock) {
+			this.data = /* @__PURE__ */ new Map();
+			for (const [k, v] of input.data) this.data.set(k, [...v]);
+		} else this.data = input;
 	}
 	/** write data to namespace, note that the `data` must be serializable in yaml */
 	write(namespace, data) {
@@ -618,4 +622,182 @@ function attachChangelog(draft, entry) {
 	draft.changelogs.push(entry);
 }
 //#endregion
-export { parseChangelogFile as a, parsePublishLock as i, validateChangelogStore as n, readChangelogEntries as o, validatePackageStore as r, createDraft as t };
+//#region src/plans/publish.ts
+async function initPublishPlan(context, options) {
+	let lock;
+	try {
+		lock = parsePublishLock(await fs.readFile(context.lockPath, "utf8"));
+	} catch {
+		return;
+	}
+	let data;
+	const packages = /* @__PURE__ */ new Map();
+	const changelogs = /* @__PURE__ */ new Map();
+	while (data = lock.read("core:changelogs")) {
+		const validated = validateChangelogStore(data);
+		if (!validated.success) continue;
+		const entry = validated.data;
+		const parsed = parseChangelogFile(entry.filename, entry.content);
+		if (!parsed) continue;
+		changelogs.set(parsed.id, parsed);
+	}
+	while (data = lock.read("core:packages")) {
+		const validated = validatePackageStore(data);
+		if (!validated.success) continue;
+		const parsed = validated.data;
+		if (!context.graph.get(parsed.id)) continue;
+		const pkgChangelogs = [];
+		for (const id of parsed.changelogIds ?? []) {
+			const entry = changelogs.get(id);
+			if (entry) pkgChangelogs.push(entry);
+		}
+		packages.set(parsed.id, {
+			changelogs: pkgChangelogs,
+			updated: parsed.updated
+		});
+	}
+	const plan = {
+		options,
+		changelogs,
+		packages
+	};
+	for (const plugin of context.plugins) await handlePluginError(plugin, "initPublishPlan", () => plugin.initPublishPlan?.call(context, {
+		lock,
+		plan
+	}));
+	return plan;
+}
+function resolvePublishTargets(plan) {
+	/** the iteration order = publish order */
+	const orderedMap = /* @__PURE__ */ new Map();
+	let lastSplitIndex = -1;
+	/** package id -> true while scanning hard wait, false while scanning optional wait */
+	const stack = /* @__PURE__ */ new Map();
+	function scan(id) {
+		const preflight = plan.packages.get(id)?.preflight;
+		if (!preflight || !preflight.shouldPublish) return;
+		switch (stack.get(id)) {
+			case true: throw new Error(`circular reference of deps: ${[...stack.keys(), id].join(" -> ")}`);
+			case false: return;
+		}
+		let ordered = orderedMap.get(id);
+		if (ordered) return ordered;
+		let split = false;
+		if (preflight.wait) {
+			stack.set(id, true);
+			for (const dep of preflight.wait) {
+				const ordered = scan(dep);
+				split ||= ordered !== void 0 && ordered.index >= lastSplitIndex;
+			}
+		}
+		if (preflight.optionalWait) {
+			stack.set(id, false);
+			for (const dep of preflight.optionalWait) {
+				const ordered = scan(dep);
+				split ||= ordered !== void 0 && ordered.index >= lastSplitIndex;
+			}
+		}
+		stack.delete(id);
+		ordered = {
+			split,
+			index: orderedMap.size
+		};
+		if (split) lastSplitIndex = ordered.index;
+		orderedMap.set(id, ordered);
+		return ordered;
+	}
+	for (const id of plan.packages.keys()) scan(id);
+	return orderedMap;
+}
+async function runPublishPlan(context, plan) {
+	const { dryRun = false, unstable_maxChunk = 5 } = plan.options;
+	for (const plugin of context.plugins) await handlePluginError(plugin, "beforePublishAll", () => plugin.beforePublishAll?.call(context, { plan }));
+	async function publish(pkg) {
+		if (dryRun) return { type: "published" };
+		try {
+			for (const plugin of context.plugins) if (await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg })) === false) return { type: "skipped" };
+			for (const plugin of context.plugins) {
+				const publishResult = await handlePluginError(plugin, "publish", () => plugin.publish?.call(context, {
+					pkg,
+					plan
+				}));
+				if (publishResult) return publishResult;
+			}
+		} catch (e) {
+			return {
+				type: "failed",
+				error: e instanceof Error ? e.message : String(e)
+			};
+		}
+		return {
+			type: "failed",
+			error: `There is no plugin to publish package "${pkg.id}", please make sure the package has a supported provider plugin.`
+		};
+	}
+	let promises = [];
+	for (const [id, { split }] of resolvePublishTargets(plan)) {
+		const pkg = context.graph.get(id);
+		const packagePlan = plan.packages.get(pkg.id);
+		if (!pkg || !packagePlan) continue;
+		if (split || promises.length >= unstable_maxChunk) {
+			await Promise.all(promises);
+			promises = [];
+		}
+		promises.push(publish(pkg).then(async (result) => {
+			packagePlan.publishResult = result;
+			if (result.type === "skipped") return;
+			for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
+				pkg,
+				plan
+			}));
+		}));
+	}
+	await Promise.all(promises);
+	for (const packagePlan of plan.packages.values()) packagePlan.publishResult ??= { type: "skipped" };
+	for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublishAll", () => plugin.afterPublishAll?.call(context, { plan }));
+}
+async function runPreflights(context, plan) {
+	const { graph } = context;
+	await Promise.all(Array.from(plan.packages, async ([id, packagePlan]) => {
+		const pkg = graph.get(id);
+		packagePlan.preflight = { shouldPublish: false };
+		if (!packagePlan.updated) return;
+		for (const plugin of context.plugins) {
+			const res = await handlePluginError(plugin, "publishPreflight", () => plugin.publishPreflight?.call(context, {
+				pkg,
+				plan
+			}));
+			if (res) {
+				packagePlan.preflight = res;
+				break;
+			}
+		}
+	}));
+	if (plan.options.packages) {
+		const only = /* @__PURE__ */ new Set();
+		function addOnly(id) {
+			if (only.has(id)) return;
+			const preflight = plan.packages.get(id)?.preflight;
+			if (!preflight) return;
+			only.add(id);
+			if (preflight.wait) for (const dep of preflight.wait) addOnly(dep);
+			if (preflight.optionalWait) for (const dep of preflight.optionalWait) addOnly(dep);
+		}
+		for (const name of plan.options.packages) for (const pkg of graph.getByName(name)) addOnly(pkg.id);
+		for (const [id, packagePlan] of plan.packages) {
+			if (only.has(id)) continue;
+			packagePlan.preflight.shouldPublish = false;
+		}
+	}
+	for (const plugin of context.plugins) await handlePluginError(plugin, "afterPreflight", () => plugin.afterPreflight?.call(context, { plan }));
+}
+async function publishPlanStatus(plan, context) {
+	for (const plugin of context.plugins) {
+		const status = await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, { plan }));
+		if (Array.isArray(status) && await somePromise(status, (v) => v === "pending")) return "pending";
+		if (status === "pending") return "pending";
+	}
+	return "success";
+}
+//#endregion
+export { createDraft as a, parseChangelogFile as c, runPublishPlan as i, readChangelogEntries as l, publishPlanStatus as n, PublishLock as o, runPreflights as r, parsePublishLock as s, initPublishPlan as t };

package/dist/{types-DEyZ2r-2.d.ts → types-BbwOrNZ2.d.ts}

@@ -560,6 +560,10 @@ interface PublishPlan {
   changelogs: Map<string, ChangelogEntry>;
   /** id -> package data. The package id will always exist in package graph, stale items will be pruned at init-time */
   packages: Map<string, PackagePublishPlan>;
+  /** generated by GitHub/GitLab plugin (internal) */
+  $versionRequest?: {
+    publishGroups: Map<string, "active" | "pending">;
+  };
 }
 interface PackagePublishPlan {
   changelogs: ChangelogEntry[];
@@ -586,6 +590,8 @@ interface PublishOptions {
    * Publish only the given packages and their dependencies.
    *
    * Each entry can be a package id, package name, or `group:name`.
+   *
+   * When empty, no packages will be published.
    */
   packages?: string[];
   /**
@@ -609,9 +615,8 @@ type PackagePublishResult = {
 declare class PublishLock {
   /** namespace -> data array */
   private readonly data;
-  constructor(/** namespace -> data array */
-
-  data?: Map<string, unknown[]>);
+  constructor(lock: PublishLock);
+  constructor(data?: Map<string, unknown[]>);
   /** write data to namespace, note that the `data` must be serializable in yaml */
   write(namespace: string, data: unknown): void;
   read(namespace: string): unknown | undefined;

package/dist/utils/index.d.ts

@@ -2,9 +2,10 @@ import { Result } from "tinyexec";
 
 //#region src/utils/error.d.ts
 declare function execFailure(context: string, result: Awaited<Result>): Error;
+declare function fetchFailure(context: string, response: Response): Promise<Error>;
 //#endregion
 //#region src/utils/common.d.ts
 declare const isCI: () => boolean;
 declare function joinPath(...paths: string[]): string;
 //#endregion
-export { execFailure, isCI, joinPath };
+export { execFailure, fetchFailure, isCI, joinPath };

package/dist/utils/index.js

@@ -1,2 +1,2 @@
-import { n as execFailure, o as isCI, s as joinPath } from "../error-BhMYq9iW.js";
-export { execFailure, isCI, joinPath };
+import { c as joinPath, n as execFailure, r as fetchFailure, s as isCI } from "../error-CAsrGb6e.js";
+export { execFailure, fetchFailure, isCI, joinPath };

package/dist/version-request-BQwP7EWa.d.ts

@@ -0,0 +1,57 @@
+import { b as TegamiContext, j as Draft, m as PublishLock, t as Awaitable, v as PublishPlan } from "./types-BbwOrNZ2.js";
+
+//#region src/utils/version-request.d.ts
+interface VersionRequestOptions {
+  /**
+   * Create the pull/merge request even outside of CI.
+   *
+   * @default false
+   */
+  forceCreate?: boolean;
+  /**
+   * Pull/merge request branch. Publish group PRs are created under `<branch>/`.
+   *
+   * @default "tegami/version-packages"
+   */
+  branch?: string;
+  /**
+   * Pull/merge request base branch.
+   *
+   * @default "main"
+   */
+  base?: string;
+  /** Publish groups to split into separate version requests. */
+  groups?: (string | string[])[];
+  /** Override details of a version request at version-time. */
+  create?: (this: TegamiContext, opts: VersionRequestContext) => Awaitable<{
+    title?: string;
+    body?: string;
+  }>;
+  /** Override commit summary & message. */
+  commit?: (this: TegamiContext, opts: {
+    type: "version-packages";
+  } | {
+    type: "update-lock";
+    store: PublishGroupStore;
+    updatedLock: PublishLock;
+  }) => Awaitable<{
+    title?: string;
+    body?: string;
+  } | undefined>;
+}
+interface VersionRequestContext {
+  draft: Draft;
+  /** predicted publish plan (after preflight) */
+  plan: PublishPlan | undefined;
+  getPreviousVersion(packageId: string): string | undefined;
+}
+/** adapter over the version request API of a git provider */
+interface PublishGroupStore {
+  /**
+   * - active: groups whose version request was merged, they stay listed until the lock is removed
+   * - pending: groups still waiting for their version request to be merged
+   */
+  groups: Record<string, "pending" | "active">;
+}
+//#endregion
+export { VersionRequestOptions as t };