tegami 1.1.3 → 1.2.0

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

@@ -1,11 +1,11 @@
 import { a as maxBump } from "./semver-EKJ8yK5U.js";
-import { r as handlePluginError } from "./error-BhMYq9iW.js";
+import { c as somePromise, 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 { 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/version-request-C24d9RIW.d.ts

@@ -0,0 +1,39 @@
+import { b as TegamiContext, j as Draft, 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;
+  }>;
+}
+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 */
+//#endregion
+export { VersionRequestOptions as t };