tegami 1.1.2 → 1.2.0

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 { a as createDraft, l as readChangelogEntries } from "../publish-v30y8Lwq.js";
 import { git } from "./git.js";
-import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-oxy16TJ1.js";
+import { t as onVersionRequest } from "../version-request-l6IJdFM6.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";
@@ -309,8 +309,38 @@ function gitlab(options = {}) {
 	function getRenderer(context) {
 		return renderer ??= createChangelogRenderer(context);
 	}
-	const cliOriginalPackageVersions = /* @__PURE__ */ new Map();
-	return [git(options), {
+	const versionRequests = onVersionRequest({
+		name: "gitlab",
+		options: options.versionMr,
+		canCreate(context) {
+			const { repo, token } = context.gitlab ?? {};
+			return Boolean(repo && token);
+		},
+		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
+			});
+			if (openMr === void 0) await createMergeRequest(repo, {
+				title: request.title,
+				body: request.body,
+				head: request.head,
+				base: request.base,
+				...api
+			});
+			else if (update) await updateMergeRequest(repo, openMr, {
+				title: request.title,
+				body: request.body,
+				base: request.base,
+				...api
+			});
+		}
+	});
+	const plugin = {
+		...versionRequests,
 		name: "gitlab",
 		init() {
 			this.gitlab = {
@@ -321,6 +351,7 @@ function gitlab(options = {}) {
 			};
 		},
 		async resolvePlanStatus({ plan }) {
+			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();
@@ -392,46 +423,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() {
-			for (const pkg of this.graph.getPackages()) cliOriginalPackageVersions.set(pkg.id, pkg.version);
-		},
-		async applyCliDraft(draft) {
-			const config = options.versionMr ?? {};
-			if (config === false || !(config.forceCreate || isCI()) || !await hasGitChanges(this.cwd)) return;
-			const repo = this.gitlab?.repo;
-			const { branch = "tegami/version-packages", base = "main" } = config;
-			const baseMR = await config.create?.call(this, { draft });
-			const mr = {
-				title: baseMR?.title ?? "Version Packages",
-				body: baseMR?.body ?? createVersionRequestBody(draft, this, cliOriginalPackageVersions, "Merge this MR to publish the versioned packages.")
-			};
-			await commitVersionBranchChanges(this.cwd, branch, mr.title);
-			const api = gitLabApiOptions(this.gitlab);
-			if (!repo) return;
-			const openMr = await findOpenMergeRequest(repo, {
-				head: branch,
-				base,
-				...api
-			});
-			if (openMr !== void 0) {
-				await updateMergeRequest(repo, openMr, {
-					title: mr.title,
-					body: mr.body,
-					base,
-					...api
-				});
-				return;
-			}
-			await createMergeRequest(repo, {
-				title: mr.title,
-				body: mr.body,
-				head: branch,
-				base,
-				...api
-			});
 		}
-	}];
+	};
+	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-B50RK1rR.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/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-B50RK1rR.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-DoPhFKji.js";
+import { n as NpmPackage, t as npm } from "../npm-DaUHTtlV.js";
 export { NpmPackage, npm };

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-B50RK1rR.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[];
@@ -582,6 +586,20 @@ interface PackagePublishPlan {
 interface PublishOptions {
   /** Validate the publish plan without publishing packages, creating tags, or running release plugins. */
   dryRun?: boolean;
+  /**
+   * 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[];
+  /**
+   * The max amount of concurrent publishes (unstable, can change in anytime).
+   *
+   * @default 5
+   */
+  unstable_maxChunk?: number;
 }
 type PackagePublishResult = {
   type: "published" | "skipped";
@@ -597,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;
@@ -628,9 +645,9 @@ interface Tegami {
    *
    * Prefer `publish()` over this if you are publishing packages, it will also check the publish status.
    */
-  publishStatus(): Promise<"pending" | "success" | "idle">;
+  publishStatus(options?: PublishOptions): Promise<"pending" | "success" | "idle">;
   /** Remove the publish lock file after publishing has finished successfully. */
-  cleanup(): Promise<{
+  cleanup(options?: PublishOptions): Promise<{
     state: "removed";
   } | {
     state: "skipped";
@@ -647,13 +664,17 @@ interface Tegami {
 declare function tegami<const Groups extends string = string>(options?: TegamiOptions<Groups>): Tegami;
 //#endregion
 //#region src/cli/core.d.ts
-interface TegamiCliCommand<Values extends Record<string, boolean | string | undefined>, Positionals extends Record<string, string | undefined>> {
-  option<const Name extends string, const T extends "string" | "boolean">(name: Name, opts: {
+type ArgValue = boolean | string | string[] | boolean[];
+type PositionalValue = string | string[];
+interface TegamiCliCommand<Values extends Record<string, ArgValue | undefined>, Positionals extends Record<string, PositionalValue | undefined>> {
+  option<const Name extends string, const T extends "string" | "boolean", const Multiple extends boolean = false>(name: Name, opts: {
     type: T;
     short?: string;
     description?: string;
-  }): TegamiCliCommand<Values & { [k in Name]?: T extends "string" ? string : boolean }, Positionals>;
+    multiple?: Multiple;
+  }): TegamiCliCommand<Values & { [k in Name]?: Multiple extends true ? T extends "string" ? string[] : boolean[] : T extends "string" ? string : boolean }, Positionals>;
   positional<const Name extends string, const Required extends boolean = true>(name: Name, required?: Required): TegamiCliCommand<Values, Positionals & { [K in Name]: Required extends true ? string : string | undefined }>;
+  positionals<const Name extends string>(name: Name): TegamiCliCommand<Values, Positionals & { [K in Name]: string[] }>;
   action(fn: (options: {
     context: TegamiContext;
     values: Values;
@@ -839,6 +860,10 @@ interface TegamiPlugin {
   resolvePlanStatus?(this: TegamiContext, opts: {
     plan: PublishPlan;
   }): Awaitable<"success" | "pending" | undefined | void | Awaitable<"success" | "pending" | undefined>[]>;
+  /** Called after preflights, before Tegami starts publishing the packages of a plan. */
+  beforePublishAll?(this: TegamiContext, opts: {
+    plan: PublishPlan;
+  }): Awaitable<void>;
   /** Called before a package will be published, return `false` to prevent from publishing. */
   willPublish?(this: TegamiContext, opts: {
     pkg: WorkspacePackage;
@@ -861,17 +886,23 @@ type Awaitable<T> = T | Promise<T>;
 type RequireFields<Obj, K extends keyof Obj> = Obj & { [R in K]-?: NonNullable<Obj[R]> };
 interface PublishPreflight {
   /**
-   * Whether the package should be published, the state **must not** be changed across different runs.
+   * Whether the package should be published, the state **must only depend on local inputs** (e.g. local `package.json` or `publish-lock.yaml`).
    *
    * To note if the package is already published, hook `resolvePlanStatus` on plugins, or skip at publish-time.
    */
   shouldPublish: boolean;
   /**
-   * Package ids that must be published before this one, this will automatically disallow circular dependency.
+   * Package ids that **must be** published before this one, this disallows circular dependency.
    *
-   * It is okay to add unpublished packages to `wait`, they will be ignored.
+   * It is okay to add unpublished packages, they will be ignored.
    */
   wait?: string[];
+  /**
+   * Package ids that **are preferred** to publish before this one, this allows circular dependency.
+   *
+   * It is okay to add unpublished packages, they will be ignored.
+   */
+  optionalWait?: string[];
 }
 //#endregion
 export { WorkspacePackage as A, NpmPackage as C, cargo as D, CargoPluginOptions as E, DraftPolicy as M, PackageDraft as N, PackageGraph as O, BumpType as P, NpmGraph as S, CargoPackage as T, PublishOptions as _, PublishPreflight as a, TegamiContext as b, TegamiPluginOption as c, GenerateChangelogOptions as d, Tegami as f, PackagePublishResult as g, PackagePublishPlan as h, PackageOptions as i, Draft as j, PackageGroup as k, NpmPluginOptions as l, PublishLock as m, GroupOptions as n, TegamiOptions as o, tegami as p, LogGenerator as r, TegamiPlugin as s, Awaitable as t, npm as u, PublishPlan as v, CargoGraph as w, DependencySpec as x, CommitChangelog as y };

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 };