tegami 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/draft-DtFyGxe8.js

@@ -0,0 +1,455 @@
+import { a as maxBump } from "./semver-EKJ8yK5U.js";
+import { i as renderChangelog, r as changelogFrontmatterSchema } from "./generate-BfYdNTFi.js";
+import { r as handlePluginError } from "./error-We7chQVJ.js";
+import { simpleGenerator } from "./generators/simple.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";
+import z from "zod";
+import { dump, load, visit } from "js-yaml";
+//#region src/utils/frontmatter.ts
+/**
+* Inspired by https://github.com/jonschlinkert/gray-matter
+*/
+const regex = /^---\r?\n(.+?)\r?\n---\r?\n?/s;
+/**
+* parse frontmatter, it supports only yaml format
+*/
+function frontmatter(input) {
+	const output = {
+		matter: "",
+		data: {},
+		content: input
+	};
+	const match = regex.exec(input);
+	if (!match) return output;
+	output.matter = match[0];
+	output.content = input.slice(match[0].length);
+	output.data = load(match[1]) ?? {};
+	return output;
+}
+//#endregion
+//#region src/changelog/parse.ts
+async function getChangelogFiles(context) {
+	return (await readdir(context.changelogDir).catch(() => [])).filter((file) => file.endsWith(".md"));
+}
+async function readChangelogEntries(context) {
+	const dir = context.changelogDir;
+	const files = await getChangelogFiles(context);
+	return (await Promise.all(files.map(async (file) => {
+		const filePath = join(dir, file);
+		const content = await readFile(filePath, "utf8");
+		return parseChangelogFile(basename(filePath), content);
+	}))).filter((v) => v !== void 0);
+}
+/** Parse one changelog markdown file into release entries. */
+function parseChangelogFile(filename, content) {
+	const parsed = frontmatter(content);
+	const { success, data } = changelogFrontmatterSchema.safeParse(parsed.data);
+	if (!success || !data.packages) return;
+	let headingBump;
+	const packages = /* @__PURE__ */ new Map();
+	const sections = [];
+	for (const section of parseMarkdownSections(parsed.content)) {
+		const sectionBumpType = headingToBump(section.depth);
+		if (sectionBumpType) headingBump = headingBump ? maxBump(headingBump, sectionBumpType) : sectionBumpType;
+		sections.push({
+			depth: section.depth,
+			title: section.title,
+			content: section.content
+		});
+	}
+	if (sections.length === 0) return;
+	if (Array.isArray(data.packages)) {
+		if (!headingBump) return;
+		for (const pkg of data.packages) packages.set(pkg, { type: headingBump });
+	} else for (const [k, v] of Object.entries(data.packages)) {
+		let config;
+		if (typeof v === "string") config = { type: v };
+		else if (v === null) config = { type: headingBump };
+		else config = v;
+		if (config.type || config.replay?.length) packages.set(k, config);
+	}
+	if (packages.size === 0) return;
+	const entry = {
+		id: filename,
+		filename,
+		subject: data.subject,
+		packages,
+		sections,
+		_raw_body: parsed.content,
+		getRawContent() {
+			return renderChangelog({
+				subject: this.subject,
+				packages: Object.fromEntries(this.packages.entries())
+			}, entry._raw_body);
+		}
+	};
+	return entry;
+}
+function parseReplayCondition(condition) {
+	if (condition.startsWith("exit prerelease:")) return {
+		type: "on-exit-prerelease",
+		name: condition.slice(16).trimStart()
+	};
+	const idx = condition.lastIndexOf("@");
+	if (idx <= 0) return null;
+	return {
+		type: "on-version",
+		name: condition.slice(0, idx),
+		version: condition.slice(idx + 1)
+	};
+}
+function parseMarkdownSections(markdown) {
+	const sections = [];
+	const lines = markdown.split(/\r\n|\r|\n/);
+	let current;
+	let fence;
+	for (const line of lines) {
+		const fenceMarker = line.match(/^ {0,3}(`{3,}|~{3,})/);
+		if (fenceMarker) {
+			const marker = fenceMarker[1];
+			if (!fence) fence = marker;
+			else if (marker[0] === fence[0] && marker.length >= fence.length) fence = void 0;
+		}
+		if (!fence) {
+			const heading = parseHeading(line);
+			if (heading) {
+				if (current) sections.push(toMarkdownSection(current));
+				current = {
+					...heading,
+					contentLines: []
+				};
+				continue;
+			}
+		}
+		current?.contentLines.push(line);
+	}
+	if (current) sections.push(toMarkdownSection(current));
+	return sections;
+}
+function parseHeading(line) {
+	const match = line.match(/^ {0,3}(#{1,6})(?:[ \t]+|$)(.*)$/);
+	if (!match) return;
+	return {
+		depth: match[1].length,
+		title: stripClosingHeadingSequence(match[2]).trim()
+	};
+}
+function stripClosingHeadingSequence(value) {
+	return value.replace(/[ \t]+#{1,}[ \t]*$/, "");
+}
+function toMarkdownSection(section) {
+	return {
+		depth: section.depth,
+		title: section.title,
+		content: section.contentLines.join("\n").trim()
+	};
+}
+function headingToBump(depth) {
+	switch (depth) {
+		case 1: return "major";
+		case 2: return "minor";
+		case 3: return "patch";
+	}
+}
+//#endregion
+//#region src/plans/lock.ts
+function inlineMultilineScalars(documents) {
+	visit(documents, (node) => {
+		if (node.kind !== "scalar" || !node.value.includes("\n")) return;
+		node.style.doubleQuoted = true;
+		node.style.literal = false;
+		node.style.folded = false;
+		node.style.singleQuoted = false;
+	});
+}
+const lockDumpOptions = {
+	sortKeys: true,
+	lineWidth: -1,
+	transform: inlineMultilineScalars
+};
+/**
+* the data structure of `publish-lock.yaml` file.
+*/
+var PublishLock = class {
+	data;
+	constructor(data = /* @__PURE__ */ new Map()) {
+		this.data = data;
+	}
+	/** write data to namespace, note that the `data` must be serializable in yaml */
+	write(namespace, data) {
+		let arr = this.data.get(namespace);
+		if (!arr) {
+			arr = [];
+			this.data.set(namespace, arr);
+		}
+		arr.push(data);
+	}
+	read(namespace) {
+		return this.data.get(namespace)?.shift();
+	}
+	size(namespace) {
+		return this.data.get(namespace)?.length ?? 0;
+	}
+	serialize() {
+		let res = dump(Object.fromEntries(this.data.entries()), lockDumpOptions);
+		if (!res.endsWith("\n")) res += "\n";
+		return res;
+	}
+};
+const baseSchema = z.record(z.string(), z.array(z.unknown()));
+function parsePublishLock(content) {
+	const data = baseSchema.parse(load(content));
+	return new PublishLock(new Map(Object.entries(data)));
+}
+//#endregion
+//#region src/plans/policy.ts
+function groupPolicy({ graph }) {
+	return {
+		id: "group",
+		onUpdate({ pkg, packageDraft }) {
+			if (!packageDraft.type) return;
+			const group = graph.getPackageGroup(pkg.id);
+			if (!group || !group.options.syncBump) return;
+			for (const member of group.packages) {
+				if (member === pkg) continue;
+				this.bumpPackage(member, {
+					type: packageDraft.type,
+					reason: `sync "${group.name}" group package versions`
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plans/draft.ts
+const changelogStoreSchema = z.object({
+	v: z.literal("0.0.0"),
+	filename: z.string(),
+	content: z.string()
+});
+const packageStoreSchema = z.object({
+	id: z.string(),
+	updated: z.boolean(),
+	changelogIds: z.array(z.string()).optional()
+});
+/** a draft describes all operations to perform before the actual publishing, such as version bumps. */
+var Draft = class {
+	context;
+	#applied = false;
+	/** package id -> draft */
+	packages = /* @__PURE__ */ new Map();
+	/** id -> changelog */
+	changelogs = /* @__PURE__ */ new Map();
+	policies = [];
+	constructor(context) {
+		this.context = context;
+		this.policies.push(groupPolicy(context));
+	}
+	getPackageDrafts() {
+		return this.packages;
+	}
+	getPackageDraft(id) {
+		return this.packages.get(id);
+	}
+	bumpPackage(pkg, { type, reason }) {
+		return this.dispatchPackage(pkg, (draft) => {
+			draft.type = draft.type ? maxBump(draft.type, type) : type;
+			if (reason) {
+				draft.bumpReasons ??= /* @__PURE__ */ new Set();
+				draft.bumpReasons.add(reason);
+			}
+		});
+	}
+	dispatchPackage(pkg, dispatch, onUpdate) {
+		const packageDraft = this.getOrInitPackage(pkg);
+		const prevVersion = packageDraft.bumpVersion(pkg);
+		dispatch(packageDraft);
+		if (prevVersion !== packageDraft.bumpVersion(pkg)) {
+			onUpdate?.(packageDraft);
+			for (const policy of this.policies) policy.onUpdate?.call(this, {
+				packageDraft,
+				pkg
+			});
+		}
+		return packageDraft;
+	}
+	getOrInitPackage(pkg) {
+		const existing = this.packages.get(pkg.id);
+		if (existing) return existing;
+		this.packages.set(pkg.id, pkg.initDraft());
+		return this.dispatchPackage(pkg, (draft) => pkg.configureDraft(draft, this.context.graph.getPackageGroup(pkg.id)), (draft) => {
+			(draft.bumpReasons ??= /* @__PURE__ */ new Set()).add("align with script-level configs");
+		});
+	}
+	hasPending() {
+		const { graph } = this.context;
+		for (const [id, draft] of this.packages) {
+			const pkg = graph.get(id);
+			if (pkg && draft.bumpVersion(pkg) !== pkg.version) return true;
+		}
+		return false;
+	}
+	/** get all changelogs, note that this includes replay-only changelogs, as long as they are in the `.tegami` folder. */
+	getChangelogs() {
+		return Array.from(this.changelogs.values());
+	}
+	getChangelog(id) {
+		return this.changelogs.get(id);
+	}
+	addChangelog(entry) {
+		this.changelogs.set(entry.id, entry);
+		const { graph } = this.context;
+		const groupPackages = /* @__PURE__ */ new Map();
+		for (const [name, config] of entry.packages) {
+			if (!config.type) continue;
+			for (const pkg of graph.getByName(name)) groupPackages.set(pkg, config.type);
+		}
+		for (const [pkg, bumpType] of groupPackages) attachChangelog(this.bumpPackage(pkg, { type: bumpType }), entry);
+	}
+	deleteChangelog(id) {
+		return this.changelogs.delete(id);
+	}
+	/** Apply version bumps, lock file, and changelog files. */
+	async apply() {
+		if (this.#applied) throw new Error("This draft has already been applied.");
+		const { graph } = this.context;
+		this.#applied = true;
+		const snapshots = /* @__PURE__ */ new Map();
+		for (const pkg of graph.getPackages()) snapshots.set(pkg.id, { version: pkg.version });
+		for (const plugin of this.context.plugins) await handlePluginError(plugin, "applyDraft", () => plugin.applyDraft?.call(this.context, this));
+		const updatedChangelogs = this.applyReplays(snapshots);
+		const writes = [];
+		for (const [id, packageDraft] of this.packages) {
+			const pkg = graph.get(id);
+			if (!pkg) continue;
+			writes.push(this.appendChangelog(pkg, packageDraft));
+		}
+		for (const entry of this.changelogs.values()) {
+			const updated = updatedChangelogs.get(entry.id);
+			const filePath = path.join(this.context.changelogDir, entry.filename);
+			if (updated) writes.push(mkdir(this.context.changelogDir, { recursive: true }).then(() => writeFile(filePath, updated.getRawContent())));
+			else if (!entry.virtual) writes.push(rm(filePath, { force: true }));
+		}
+		writes.push(this.writeLockFile(snapshots));
+		await Promise.all(writes);
+	}
+	/** write persistent data to publish lock */
+	async writeLockFile(snapshots) {
+		const lock = new PublishLock();
+		const changelogs = /* @__PURE__ */ new Set();
+		for (const pkg of this.context.graph.getPackages()) {
+			const draft = this.getPackageDraft(pkg.id);
+			const snapshot = snapshots.get(pkg.id);
+			if (!snapshot) continue;
+			for (const entry of draft?.changelogs ?? []) changelogs.add(entry);
+			lock.write("core:packages", {
+				id: pkg.id,
+				updated: draft !== void 0 && snapshot.version !== pkg.version,
+				changelogIds: draft?.changelogs?.map((entry) => entry.id)
+			});
+		}
+		for (const entry of changelogs) lock.write("core:changelogs", {
+			v: "0.0.0",
+			filename: entry.filename,
+			content: entry.getRawContent()
+		});
+		for (const plugin of this.context.plugins) await handlePluginError(plugin, "initPublishLock", () => plugin.initPublishLock?.call(this.context, {
+			lock,
+			draft: this
+		}));
+		await mkdir(dirname(this.context.lockPath), { recursive: true });
+		await writeFile(this.context.lockPath, lock.serialize());
+	}
+	addPolicy(policy) {
+		this.policies.push(policy);
+	}
+	removePolicy(policy) {
+		const idx = this.policies.indexOf(policy);
+		if (idx !== -1) this.policies.splice(idx, 1);
+	}
+	canApply() {
+		return !this.#applied;
+	}
+	/** Attach replaying changelog entries to packages (already bumped), and return the updated changelog entries. */
+	applyReplays(snapshots) {
+		const updated = /* @__PURE__ */ new Map();
+		const { graph } = this.context;
+		const defaultReplays = (name) => {
+			const replay = [];
+			for (const pkg of graph.getByName(name)) if (this.packages.get(pkg.id)?.prerelease) replay.push(`exit prerelease: ${pkg.id}`);
+			return replay;
+		};
+		const isMatch = (condition) => {
+			if (condition.type === "on-exit-prerelease") return graph.getByName(condition.name).some((pkg) => {
+				const previous = snapshots.get(pkg.id);
+				return previous?.version && semver$1.inc(previous.version, "release") === pkg.version;
+			});
+			return graph.getByName(condition.name).some((pkg) => pkg.version === condition.version);
+		};
+		for (const entry of this.changelogs.values()) {
+			const updatedPackages = /* @__PURE__ */ new Map();
+			const matchedNames = /* @__PURE__ */ new Set();
+			for (const [name, config] of entry.packages) {
+				let replay = config.replay;
+				if (config.type) replay ??= defaultReplays(name);
+				if (!replay || replay.length === 0) continue;
+				replay = replay.filter((item) => {
+					const condition = parseReplayCondition(item);
+					if (condition && isMatch(condition)) {
+						matchedNames.add(name);
+						return false;
+					}
+					return true;
+				});
+				if (replay.length === 0) continue;
+				const updatedConfig = {
+					...config,
+					replay
+				};
+				delete updatedConfig.type;
+				updatedPackages.set(name, updatedConfig);
+			}
+			if (updatedPackages.size > 0) updated.set(entry.id, {
+				...entry,
+				packages: updatedPackages
+			});
+			for (const name of matchedNames) for (const pkg of graph.getByName(name)) attachChangelog(this.getOrInitPackage(pkg), entry);
+		}
+		return updated;
+	}
+	async appendChangelog(pkg, draft) {
+		if (!draft.changelogs || draft.changelogs.length === 0) return;
+		const { generator = simpleGenerator() } = this.context.options;
+		const generated = await generator.generate.call(this.context, {
+			pkg,
+			packageDraft: draft,
+			draft: this
+		});
+		const path = join(pkg.path, "CHANGELOG.md");
+		const existing = await readFile(path, "utf8").catch(() => "");
+		await writeFile(path, `${generated.trim()}\n\n${existing}`.trimEnd() + "\n");
+	}
+	/** {@link apply} but for `await using` syntax */
+	async [Symbol.asyncDispose]() {
+		return this.apply();
+	}
+};
+async function createDraft(changelogs, context) {
+	let draft = new Draft(context);
+	for (const plugin of context.plugins) {
+		const result = await handlePluginError(plugin, "initDraft", () => plugin.initDraft?.call(context, draft));
+		if (result) draft = result;
+	}
+	for (const pkg of context.graph.getPackages()) draft.getOrInitPackage(pkg);
+	for (const entry of changelogs) draft.addChangelog(entry);
+	return draft;
+}
+function attachChangelog(draft, entry) {
+	if (draft.changelogs?.some((item) => item.id === entry.id)) return;
+	draft.changelogs ??= [];
+	draft.changelogs.push(entry);
+}
+//#endregion
+export { parseChangelogFile as a, parsePublishLock as i, createDraft as n, readChangelogEntries as o, packageStoreSchema as r, changelogStoreSchema as t };

package/dist/{error-D3dwQnwR.js → error-We7chQVJ.js}

@@ -20,6 +20,17 @@ async function somePromise(promises, fn) {
 		}
 	});
 }
+function cached(cacheKey, fn, cacheMap = /* @__PURE__ */ new Map()) {
+	return (...args) => {
+		const key = cacheKey(...args);
+		let out = cacheMap.get(key);
+		if (!out) {
+			out = fn(...args);
+			cacheMap.set(key, out);
+		}
+		return out;
+	};
+}
 //#endregion
 //#region src/utils/error.ts
 var CancelledError = class extends Error {
@@ -62,4 +73,4 @@ async function handlePluginError(plugin, hookName, callback) {
 	}
 }
 //#endregion
-export { isCI as a, isNodeError as i, execFailure as n, somePromise as o, handlePluginError as r, CancelledError as t };
+export { cached as a, isNodeError as i, execFailure as n, isCI as o, handlePluginError as r, somePromise as s, CancelledError as t };

package/dist/{generate-CaCDNfVk.js → generate-BfYdNTFi.js}

@@ -1,5 +1,5 @@
 import { a as maxBump, t as bumpDepth } from "./semver-EKJ8yK5U.js";
-import { n as execFailure } from "./error-D3dwQnwR.js";
+import { n as execFailure } from "./error-We7chQVJ.js";
 import { x } from "tinyexec";
 import z from "zod";
 import { dump } from "js-yaml";

package/dist/generators/simple.d.ts

@@ -1,4 +1,4 @@
-import { r as LogGenerator } from "../types-DKeF_CDv.js";
+import { r as LogGenerator } from "../types-DKZsadC8.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-import { C as WorkspacePackage, E as PackageDraft, S as PackageGroup, T as DraftPolicy, a as PublishPreflight, c as TegamiPluginOption, d as PackagePublishResult, f as PublishOptions, i as PackageOptions, l as PublishLock, n as GroupOptions, o as TegamiOptions, p as PublishPlan, r as LogGenerator, s as TegamiPlugin, u as PackagePublishPlan, w as Draft, x as PackageGraph } from "./types-DKeF_CDv.js";
-import { i as CommitChangelog, n as Tegami, r as tegami, t as GenerateChangelogOptions } from "./index-CQXmwyLn.js";
+import { A as PackageDraft, D as WorkspacePackage, E as PackageGroup, O as Draft, T as PackageGraph, _ as PublishPlan, a as PublishPreflight, c as TegamiPluginOption, d as tegami, f as CommitChangelog, g as PublishOptions, h as PackagePublishResult, i as PackageOptions, k as DraftPolicy, l as GenerateChangelogOptions, m as PackagePublishPlan, n as GroupOptions, o as TegamiOptions, p as PublishLock, r as LogGenerator, s as TegamiPlugin, u as Tegami } from "./types-DKZsadC8.js";
 export { type CommitChangelog, type Draft, type DraftPolicy, GenerateChangelogOptions, type GroupOptions, type LogGenerator, type PackageDraft, type PackageGraph, type PackageGroup, type PackageOptions, type PackagePublishPlan, type PackagePublishResult, type PublishLock, type PublishOptions, type PublishPlan, type PublishPreflight, Tegami, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, type WorkspacePackage, tegami };