tegami 0.1.6 → 0.2.1

package/dist/checks-azjuIFt7.js

@@ -1,109 +0,0 @@
-import { r as handlePluginError } from "./error-DNy8R5ue.js";
-import { n as jsonCodec, t as bumpTypeSchema } from "./schemas-CurBAaW5.js";
-import z$1 from "zod";
-import { dump } from "js-yaml";
-import { readFile } from "fs/promises";
-//#region src/changelog/shared.ts
-const changelogPackageConfigSchema = z$1.object({
-	type: bumpTypeSchema.optional(),
-	replay: z$1.array(z$1.string().min(1)).optional()
-});
-const changelogFrontmatterSchema = z$1.object({
-	subject: z$1.string().optional(),
-	packages: z$1.union([z$1.array(z$1.string()), z$1.record(z$1.string(), z$1.union([
-		bumpTypeSchema,
-		z$1.null(),
-		changelogPackageConfigSchema
-	]))]).optional()
-});
-function renderChangelog(frontmatter, body) {
-	return [
-		"---",
-		dump(frontmatter).trim(),
-		"---",
-		"",
-		body.trim(),
-		""
-	].join("\n");
-}
-//#endregion
-//#region src/plans/store.ts
-const packagePlanStoreSchema = z$1.object({
-	type: bumpTypeSchema.optional(),
-	changelogIds: z$1.array(z$1.string()).optional(),
-	bumpReasons: z$1.array(z$1.string()).optional(),
-	npm: z$1.object({ distTag: z$1.string().optional() }).optional(),
-	publish: z$1.boolean()
-});
-/** the persisted plan data for actual publishing */
-const planStoreSchema = jsonCodec(z$1.object({
-	id: z$1.string(),
-	createdAt: z$1.iso.datetime(),
-	version: z$1.literal("0.0.0").default("0.0.0"),
-	/** release note entries */
-	changelogs: z$1.record(z$1.string(), z$1.object({
-		filename: z$1.string(),
-		content: z$1.string()
-	})),
-	/** package id -> package info */
-	packages: z$1.record(z$1.string(), packagePlanStoreSchema)
-}));
-function createPlanStore(draft, context) {
-	const store = {
-		version: "0.0.0",
-		id: `tegami-${Date.now().toString(36)}`,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		changelogs: {},
-		packages: {}
-	};
-	for (const entry of draft.getChangelogs()) store.changelogs[entry.id] = {
-		filename: entry.filename,
-		content: entry.getRawContent()
-	};
-	for (const pkg of context.graph.getPackages()) {
-		const plan = draft.getPackagePlan(pkg.id);
-		if (plan) store.packages[pkg.id] = {
-			publish: plan.publish ?? false,
-			type: plan.type,
-			npm: plan.npm,
-			changelogIds: plan.changelogs?.map((entry) => entry.id),
-			bumpReasons: plan.bumpReasons ? Array.from(plan.bumpReasons) : void 0
-		};
-	}
-	return planStoreSchema.encode(store);
-}
-async function readPlanStore(context) {
-	try {
-		return planStoreSchema.decode(await readFile(context.planPath, "utf8"));
-	} catch {}
-}
-//#endregion
-//#region src/plans/checks.ts
-async function publishPlanStatus(store, context) {
-	async function defaultStatus() {
-		try {
-			await Promise.all(Object.entries(store.packages).map(async ([id, plan]) => {
-				const pkg = context.graph.get(id);
-				if (!pkg || !plan.publish) return;
-				if (!await context.getRegistryClient(pkg).isPackagePublished(pkg)) throw "pending";
-			}));
-			return { state: "success" };
-		} catch (err) {
-			if (err === "pending") return { state: "pending" };
-			throw err;
-		}
-	}
-	let status = await defaultStatus();
-	for (const plugin of context.plugins) {
-		const resolved = await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, status, { plan: store }));
-		if (resolved) status = resolved;
-	}
-	return status;
-}
-async function assertPublishPlanFinished(context) {
-	const store = await readPlanStore(context);
-	if (!store) return;
-	if ((await publishPlanStatus(store, context)).state === "pending") throw new Error(`Publish plan already exists at ${context.planPath} and is pending. Publish it before applying a new plan.`);
-}
-//#endregion
-export { changelogFrontmatterSchema as a, readPlanStore as i, publishPlanStatus as n, renderChangelog as o, createPlanStore as r, assertPublishPlanFinished as t };

package/dist/publish-DkRT0yh6.js

@@ -1,282 +0,0 @@
-import { a as maxBump } from "./semver-C4vJ4SK8.js";
-import { r as handlePluginError } from "./error-DNy8R5ue.js";
-import { a as changelogFrontmatterSchema, n as publishPlanStatus } from "./checks-azjuIFt7.js";
-import { readFile, readdir } from "node:fs/promises";
-import { basename, join } from "node:path";
-import { dump, load } from "js-yaml";
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { toMarkdown } from "mdast-util-to-markdown";
-//#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;
-	const tree = fromMarkdown(parsed.content);
-	let headingBump;
-	const packages = /* @__PURE__ */ new Map();
-	const sections = [];
-	for (const section of getHeadingSections(tree)) {
-		const sectionBumpType = headingToBump(section.heading.depth);
-		if (sectionBumpType) headingBump = headingBump ? maxBump(headingBump, sectionBumpType) : sectionBumpType;
-		sections.push({
-			depth: section.heading.depth,
-			title: sectionToMarkdown(section.heading.children),
-			content: sectionToMarkdown(section.children)
-		});
-	}
-	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 [
-				"---",
-				dump({
-					subject: this.subject,
-					packages: Object.fromEntries(this.packages.entries())
-				}).trim(),
-				"---",
-				"",
-				entry._raw_body.trim(),
-				""
-			].join("\n");
-		}
-	};
-	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 getHeadingSections(tree) {
-	const sections = [];
-	let current;
-	for (const child of tree.children) {
-		if (child.type === "heading") {
-			current = {
-				heading: child,
-				children: []
-			};
-			sections.push(current);
-			continue;
-		}
-		current?.children.push(child);
-	}
-	return sections;
-}
-function sectionToMarkdown(children) {
-	if (children.length === 0) return "";
-	return toMarkdown({
-		type: "root",
-		children
-	}, {
-		bullet: "-",
-		fence: "`"
-	}).trim();
-}
-function headingToBump(depth) {
-	switch (depth) {
-		case 1: return "major";
-		case 2: return "minor";
-		case 3: return "patch";
-	}
-}
-//#endregion
-//#region src/publish.ts
-async function resolvePublishTargets(context, store) {
-	const targets = [];
-	const preflightPromises = [];
-	for (const [id, plan] of Object.entries(store.packages)) {
-		if (!plan.publish) continue;
-		const pkg = context.graph.get(id);
-		if (!pkg) continue;
-		targets.push(pkg.id);
-		preflightPromises.push(context.getRegistryClient(pkg).publishPreflight?.(pkg, {
-			store,
-			packageStore: plan
-		}));
-	}
-	const preflights = await Promise.all(preflightPromises);
-	const children = /* @__PURE__ */ new Map();
-	for (let i = 0; i < targets.length; i++) {
-		const id = targets[i];
-		children.set(id, preflights[i]?.wait);
-	}
-	const ordered = [];
-	function scan(id, stack = /* @__PURE__ */ new Set()) {
-		if (stack.has(id)) throw new Error(`circular reference of deps: ${[...stack, id].join(" -> ")}`);
-		if (ordered.includes(id)) return;
-		const deps = children.get(id);
-		if (deps) {
-			stack.add(id);
-			for (const dep of deps) scan(dep, stack);
-			stack.delete(id);
-		}
-		ordered.push(id);
-	}
-	for (const id of targets) scan(id);
-	return ordered;
-}
-async function publishFromPlan(context, store, options) {
-	const { dryRun = false } = options;
-	const packages = [];
-	if ((await publishPlanStatus(store, context)).state !== "pending") return { state: "skipped" };
-	const orderedIds = await resolvePublishTargets(context, store);
-	const parsedChangelogs = /* @__PURE__ */ new Map();
-	for (const [id, entry] of Object.entries(store.changelogs)) {
-		const parsed = parseChangelogFile(entry.filename, entry.content);
-		if (!parsed) continue;
-		parsedChangelogs.set(id, parsed);
-	}
-	for (const id of orderedIds) {
-		const plan = store.packages[id];
-		const pkg = context.graph.get(id);
-		const registryClient = context.getRegistryClient(pkg);
-		const changelogs = [];
-		for (const id of plan.changelogIds ?? []) {
-			const entry = parsedChangelogs.get(id);
-			if (entry) changelogs.push(entry);
-		}
-		if (dryRun) {
-			packages.push({
-				id: pkg.id,
-				name: pkg.name,
-				version: pkg.version,
-				npm: plan.npm,
-				state: "success",
-				changelogs
-			});
-			continue;
-		}
-		if (await registryClient.isPackagePublished(pkg)) {
-			packages.push({
-				id: pkg.id,
-				name: pkg.name,
-				version: pkg.version,
-				npm: plan.npm,
-				state: "success",
-				changelogs
-			});
-			continue;
-		}
-		try {
-			let result;
-			for (const plugin of context.plugins) {
-				const next = await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg }));
-				if (next !== void 0) {
-					result = next;
-					break;
-				}
-			}
-			if (result === void 0) {
-				await registryClient.publish(pkg, {
-					packageStore: plan,
-					store
-				});
-				result = {
-					id: pkg.id,
-					name: pkg.name,
-					version: pkg.version,
-					npm: plan.npm,
-					state: "success",
-					changelogs
-				};
-			}
-			if (result === false) continue;
-			for (const plugin of context.plugins) {
-				const next = await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
-					pkg,
-					result
-				}));
-				if (next) result = next;
-			}
-			packages.push(result);
-		} catch (error) {
-			packages.push({
-				id: pkg.id,
-				name: pkg.name,
-				version: pkg.version,
-				npm: plan.npm,
-				changelogs,
-				state: "failed",
-				error: error instanceof Error ? error.message : String(error)
-			});
-		}
-	}
-	if (packages.length === 0) return { state: "skipped" };
-	return {
-		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "created",
-		packages,
-		_rawPlan: store
-	};
-}
-function publishError(result, error) {
-	result.state = "failed";
-	if (result.state === "failed" && error) result.error = result.error ? `${result.error}\n${error}` : error;
-}
-function packagePublishError(result, packageResult, error) {
-	result.state = "failed";
-	packageResult.state = "failed";
-	if (packageResult.state === "failed" && error) packageResult.error = packageResult.error ? `${packageResult.error}\n${error}` : error;
-}
-//#endregion
-export { readChangelogEntries as a, parseReplayCondition as i, publishError as n, publishFromPlan as r, packagePublishError as t };

package/dist/schemas-CurBAaW5.js

@@ -1,42 +0,0 @@
-import { z } from "zod";
-//#region src/schemas.ts
-const stringRecordSchema = z.record(z.string(), z.string());
-const bumpTypeSchema = z.enum([
-	"major",
-	"minor",
-	"patch"
-]);
-const jsonCodec = (schema) => z.codec(z.string(), schema, {
-	decode: (jsonString, ctx) => {
-		try {
-			return JSON.parse(jsonString);
-		} catch (err) {
-			ctx.issues.push({
-				code: "invalid_format",
-				format: "json",
-				input: jsonString,
-				message: err.message
-			});
-			return z.NEVER;
-		}
-	},
-	encode: (value) => JSON.stringify(value)
-});
-const pnpmWorkspaceSchema = z.looseObject({ packages: z.array(z.string()).optional() });
-const packageManifestSchema = z.looseObject({
-	name: z.string(),
-	version: z.string().optional(),
-	private: z.boolean().optional(),
-	publishConfig: z.looseObject({
-		access: z.enum(["public", "restricted"]).optional(),
-		registry: z.string().optional(),
-		tag: z.string().optional()
-	}).optional(),
-	workspaces: z.array(z.string()).optional(),
-	dependencies: stringRecordSchema.optional(),
-	devDependencies: stringRecordSchema.optional(),
-	peerDependencies: stringRecordSchema.optional(),
-	optionalDependencies: stringRecordSchema.optional()
-});
-//#endregion
-export { pnpmWorkspaceSchema as i, jsonCodec as n, packageManifestSchema as r, bumpTypeSchema as t };