keepchanges 0.0.3 → 1.0.0-beta.1

package/dist/commit-FX77u6Sj.mjs

@@ -0,0 +1,190 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { normalizeFull } from "verkit";
+//#region src/config.ts
+const defaultConfig = {
+	cli: {
+		output: "CHANGELOG.md",
+		to: "HEAD",
+		dry: false,
+		commit: false,
+		release: false,
+		author: "github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>",
+		draft: false
+	},
+	changelog: {
+		emoji: true,
+		capitalize: true,
+		group: true,
+		breakingChanges: {
+			emoji: "🚨",
+			title: "Breaking Changes"
+		},
+		types: {
+			feat: {
+				emoji: "🚀",
+				title: "Features"
+			},
+			fix: {
+				emoji: "🐞",
+				title: "Bug Fixes"
+			},
+			perf: {
+				emoji: "🏎",
+				title: "Performance"
+			}
+		},
+		messages: {
+			noSignificantChanges: "No significant changes",
+			viewChanges: "View changes on {provider}"
+		}
+	}
+};
+function resolveChangelogConfig(overrides = {}) {
+	return {
+		...defaultConfig.changelog,
+		...overrides,
+		breakingChanges: {
+			...defaultConfig.changelog.breakingChanges,
+			...overrides.breakingChanges
+		},
+		types: overrides.types ?? defaultConfig.changelog.types,
+		messages: {
+			...defaultConfig.changelog.messages,
+			...overrides.messages
+		}
+	};
+}
+//#endregion
+//#region src/changelog.ts
+function generateChangelog(options, overrides = {}) {
+	const config = resolveChangelogConfig(overrides);
+	const changes = [...renderSection(options.commits.filter((commit) => commit.isBreaking), config.breakingChanges, config, options.repository), ...Object.entries(config.types).flatMap(([type, section]) => renderSection(options.commits.filter((commit) => !commit.isBreaking && commit.type === type), section, config, options.repository))];
+	const body = [...changes.length ? changes : [`*${config.messages.noSignificantChanges}*`], ...options.repository && options.comparisonFrom ? ["", `##### &nbsp;&nbsp;&nbsp;&nbsp;[${config.messages.viewChanges.replace("{provider}", options.repository.provider.name)}](${options.repository.provider.compareUrl(options.repository, options.comparisonFrom, `v${options.version}`)})`] : []].join("\n").trim();
+	return {
+		body,
+		release: [
+			`## v${options.version}`,
+			"",
+			body,
+			""
+		].join("\n")
+	};
+}
+async function readChangelog(path) {
+	return readFile(path, "utf8").catch((error) => {
+		if (error.code === "ENOENT") return "# Changelog\n";
+		throw error;
+	});
+}
+function writeChangelog(path, changelog) {
+	return writeFile(path, changelog);
+}
+function hasRelease(changelog, version) {
+	const releaseVersion = normalizeFull(version);
+	return releaseHeadings(changelog).some((heading) => heading.version === releaseVersion);
+}
+function insertRelease(changelog, release) {
+	const releaseVersion = releaseHeadings(release)[0]?.version;
+	const headings = releaseHeadings(changelog);
+	const existingReleaseIndex = headings.findIndex((heading) => heading.version === releaseVersion);
+	if (existingReleaseIndex !== -1) {
+		const start = headings[existingReleaseIndex].index;
+		const end = headings[existingReleaseIndex + 1]?.index ?? changelog.length;
+		changelog = changelog.slice(0, start) + changelog.slice(end);
+	}
+	const firstRelease = releaseHeadings(changelog)[0];
+	if (!firstRelease) return `${changelog.trimEnd()}\n\n${release.trim()}\n`;
+	const preamble = changelog.slice(0, firstRelease.index).trimEnd();
+	const history = changelog.slice(firstRelease.index).trim();
+	return `${preamble}\n\n${release.trim()}\n\n${history}\n`;
+}
+function releaseHeadings(changelog) {
+	return [...changelog.matchAll(/^##[^\S\r\n]+(\S+)/gm)].flatMap((heading) => {
+		const version = normalizeFull(heading[1]);
+		return version ? [{
+			index: heading.index,
+			version
+		}] : [];
+	});
+}
+function renderSection(commits, section, config, repository) {
+	const renderedCommits = commits.map((commit) => {
+		const reference = repository ? `[<samp>(${commit.hash.slice(0, 5)})</samp>](${repository.provider.commitUrl(repository, commit.hash)})` : "";
+		const authorNames = commit.authors.map((author) => author.login ? `@${author.login}` : `**${escapeHtml(author.name)}**`);
+		const authors = authorNames.length > 1 ? `${authorNames.slice(0, -1).join(", ")} and ${authorNames.at(-1)}` : authorNames[0] || "";
+		const pullRequests = commit.pullRequests.map((pullRequest) => repository ? `[${pullRequest}](${repository.provider.pullRequestUrl(repository, pullRequest)})` : pullRequest).join(", ");
+		const details = [
+			authors ? `by ${authors}` : "",
+			pullRequests ? `in ${pullRequests}` : "",
+			reference
+		].filter(Boolean).join(" ");
+		const description = config.capitalize ? capitalize(commit.description) : commit.description;
+		const suffix = details ? ` &nbsp;-&nbsp; ${details}` : "";
+		return {
+			scope: commit.scope,
+			line: `${escapeHtml(description)}${suffix}`
+		};
+	});
+	if (!renderedCommits.length) return [];
+	const commitsByScope = /* @__PURE__ */ new Map();
+	for (const { scope, line } of renderedCommits) {
+		const lines = commitsByScope.get(scope) || [];
+		lines.push(line);
+		commitsByScope.set(scope, lines);
+	}
+	const lines = config.group && [...commitsByScope].some(([scope, lines]) => Boolean(scope) && lines.length > 1) ? [...commitsByScope.keys()].sort().flatMap((scope) => {
+		const scopedLines = (commitsByScope.get(scope) || []).reverse().map((line) => `${scope ? "  " : ""}- ${line}`);
+		return scope ? [`- **${escapeHtml(scope)}**:`, ...scopedLines] : scopedLines;
+	}) : renderedCommits.reverse().map(({ scope, line }) => {
+		return `- ${scope ? `**${escapeHtml(scope)}**: ` : ""}${line}`;
+	});
+	return [
+		"",
+		`### ${[config.emoji ? section.emoji : "", section.title].filter(Boolean).join(" ")}`,
+		"",
+		...lines
+	];
+}
+function capitalize(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function escapeHtml(value) {
+	const htmlEntities = {
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	};
+	return value.replace(/[&<>"']/g, (character) => htmlEntities[character]);
+}
+//#endregion
+//#region src/commit.ts
+function parseCommits(commits) {
+	return commits.map(parseCommit).filter((commit) => commit !== null);
+}
+function parseCommit(commit) {
+	const match = /^(?<type>[a-z]+)(?:\((?<scope>[^()\r\n]+)\))?(?<breaking>!)?: (?<description>.+)$/i.exec(commit.subject);
+	if (!match?.groups) return null;
+	const pullRequestPattern = /\([ a-z]*(#\d+)\s*\)/gi;
+	const pullRequests = [...new Set([...match.groups.description.matchAll(pullRequestPattern)].map((reference) => reference[1]))];
+	const authors = [commit.author];
+	for (const coAuthor of commit.body.matchAll(/^Co-Authored-By:([^<\r\n]+)<([^>\r\n]+)>[^\S\r\n]*$/gim)) {
+		const email = coAuthor[2].trim();
+		if (!authors.some((author) => author.email === email)) authors.push({
+			name: coAuthor[1].trim(),
+			email
+		});
+	}
+	return {
+		hash: commit.hash,
+		authors: authors.filter((author) => !/\[bot\]|dependabot|\(bot\)/i.test(author.name)),
+		type: match.groups.type.toLowerCase(),
+		scope: match.groups.scope || "",
+		description: match.groups.description.replace(pullRequestPattern, "").trim(),
+		pullRequests,
+		isBreaking: Boolean(match.groups.breaking) || /^BREAKING(?: |-)CHANGE:/im.test(commit.body)
+	};
+}
+//#endregion
+export { insertRelease as a, defaultConfig as c, hasRelease as i, resolveChangelogConfig as l, parseCommits as n, readChangelog as o, generateChangelog as r, writeChangelog as s, parseCommit as t };

package/dist/index.d.mts

@@ -0,0 +1,152 @@
+//#region src/repository.d.ts
+interface RepositoryAuthor {
+  name: string;
+  email: string;
+  login?: string;
+}
+interface RepositoryCommit {
+  hash: string;
+  authors: RepositoryAuthor[];
+}
+interface Repository {
+  provider: RepositoryProvider;
+  path: string;
+  webUrl: string;
+}
+interface RepositoryRelease {
+  tag: string;
+  name: string;
+  body: string;
+  prerelease: boolean;
+  draft: boolean;
+}
+interface RepositoryReleaseResult {
+  url: string;
+  action: 'created' | 'updated';
+}
+interface RepositoryProvider {
+  name: string;
+  parse: (source: string) => Repository | undefined;
+  token: (explicit: string | undefined, env: NodeJS.ProcessEnv) => string | undefined;
+  commitUrl: (repository: Repository, hash: string) => string;
+  pullRequestUrl: (repository: Repository, reference: string) => string;
+  compareUrl: (repository: Repository, from: string, to: string) => string;
+  resolveAuthors?: (commits: RepositoryCommit[], repository: Repository, token: string, fetch: typeof globalThis.fetch) => Promise<void>;
+  publishRelease?: (repository: Repository, release: RepositoryRelease, token: string, fetch: typeof globalThis.fetch) => Promise<RepositoryReleaseResult>;
+  manualReleaseUrl?: (repository: Repository, release: RepositoryRelease) => string;
+}
+//#endregion
+//#region src/git.d.ts
+interface RawCommit {
+  hash: string;
+  subject: string;
+  body: string;
+  author: RepositoryAuthor;
+}
+//#endregion
+//#region src/commit.d.ts
+interface Commit extends RepositoryCommit {
+  type: string;
+  scope: string;
+  description: string;
+  pullRequests: string[];
+  isBreaking: boolean;
+}
+declare function parseCommits(commits: RawCommit[]): Commit[];
+declare function parseCommit(commit: RawCommit): Commit | null;
+//#endregion
+//#region src/config.d.ts
+interface ChangelogSectionConfig {
+  emoji: string;
+  title: string;
+}
+interface ChangelogMessages {
+  noSignificantChanges: string;
+  viewChanges: string;
+}
+interface ChangelogConfig {
+  emoji: boolean;
+  capitalize: boolean;
+  group: boolean;
+  breakingChanges: ChangelogSectionConfig;
+  types: Record<string, ChangelogSectionConfig>;
+  messages: ChangelogMessages;
+}
+interface ChangelogConfigOverrides {
+  emoji?: boolean;
+  capitalize?: boolean;
+  group?: boolean;
+  breakingChanges?: Partial<ChangelogSectionConfig>;
+  types?: Record<string, ChangelogSectionConfig>;
+  messages?: Partial<ChangelogMessages>;
+}
+interface KeepChangesConfig {
+  cli: {
+    output: string;
+    to: string;
+    dry: boolean;
+    commit: boolean;
+    release: boolean;
+    author: string;
+    draft: boolean;
+  };
+  changelog: ChangelogConfig;
+}
+declare const defaultConfig: {
+  cli: {
+    output: string;
+    to: string;
+    dry: false;
+    commit: false;
+    release: false;
+    author: string;
+    draft: false;
+  };
+  changelog: {
+    emoji: true;
+    capitalize: true;
+    group: true;
+    breakingChanges: {
+      emoji: string;
+      title: string;
+    };
+    types: {
+      feat: {
+        emoji: string;
+        title: string;
+      };
+      fix: {
+        emoji: string;
+        title: string;
+      };
+      perf: {
+        emoji: string;
+        title: string;
+      };
+    };
+    messages: {
+      noSignificantChanges: string;
+      viewChanges: string;
+    };
+  };
+};
+declare function resolveChangelogConfig(overrides?: ChangelogConfigOverrides): ChangelogConfig;
+//#endregion
+//#region src/changelog.d.ts
+interface GenerateChangelogOptions {
+  version: string;
+  commits: Commit[];
+  repository?: Repository;
+  comparisonFrom?: string;
+}
+interface GeneratedChangelog {
+  body: string;
+  release: string;
+}
+declare function generateChangelog(options: GenerateChangelogOptions, overrides?: ChangelogConfigOverrides): GeneratedChangelog;
+declare function readChangelog(path: string): Promise<string>;
+declare function writeChangelog(path: string, changelog: string): Promise<void>;
+declare function hasRelease(changelog: string, version: string): boolean;
+declare function insertRelease(changelog: string, release: string): string;
+//#endregion
+export { type ChangelogConfig, type ChangelogConfigOverrides, type ChangelogMessages, type ChangelogSectionConfig, type Commit, type GenerateChangelogOptions, type GeneratedChangelog, type KeepChangesConfig, type RawCommit, type Repository, type RepositoryAuthor, type RepositoryCommit, type RepositoryProvider, type RepositoryRelease, type RepositoryReleaseResult, defaultConfig, generateChangelog, hasRelease, insertRelease, parseCommit, parseCommits, readChangelog, resolveChangelogConfig, writeChangelog };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { a as insertRelease, c as defaultConfig, i as hasRelease, l as resolveChangelogConfig, n as parseCommits, o as readChangelog, r as generateChangelog, s as writeChangelog, t as parseCommit } from "./commit-FX77u6Sj.mjs";
+export { defaultConfig, generateChangelog, hasRelease, insertRelease, parseCommit, parseCommits, readChangelog, resolveChangelogConfig, writeChangelog };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "keepchanges",
   "type": "module",
-  "version": "0.0.3",
+  "version": "1.0.0-beta.1",
   "description": "Generate and maintain CHANGELOG.md from Conventional Commits.",
   "author": "edram",
   "license": "MIT",
@@ -20,12 +20,11 @@
     "git"
   ],
   "exports": {
-    ".": "./dist/cli.mjs",
-    "./cli": "./dist/cli.mjs",
+    ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
   "bin": {
-    "changelog": "./dist/cli.mjs"
+    "keepchanges": "./dist/cli.mjs"
   },
   "files": [
     "dist"