/
get-changelog-entry.ts
109 lines (97 loc) 路 3.24 KB
/
get-changelog-entry.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
import { ChangelogFunctions, NewChangesetWithCommit } from "@changesets/types";
import { ModCompWithPackage } from "@changesets/types";
import startCase from "lodash.startcase";
import { shouldUpdateDependencyBasedOnConfig } from "./utils";
type ChangelogLines = {
major: Array<Promise<string>>;
minor: Array<Promise<string>>;
patch: Array<Promise<string>>;
};
async function generateChangesForVersionTypeMarkdown(
obj: ChangelogLines,
type: keyof ChangelogLines
) {
let releaseLines = await Promise.all(obj[type]);
releaseLines = releaseLines.filter((x) => x);
if (releaseLines.length) {
return `### ${startCase(type)} Changes\n\n${releaseLines.join("\n")}\n`;
}
}
// release is the package and version we are releasing
export default async function getChangelogEntry(
release: ModCompWithPackage,
releases: ModCompWithPackage[],
changesets: NewChangesetWithCommit[],
changelogFuncs: ChangelogFunctions,
changelogOpts: any,
{
updateInternalDependencies,
onlyUpdatePeerDependentsWhenOutOfRange,
}: {
updateInternalDependencies: "patch" | "minor";
onlyUpdatePeerDependentsWhenOutOfRange: boolean;
}
) {
if (release.type === "none") return null;
const changelogLines: ChangelogLines = {
major: [],
minor: [],
patch: [],
};
// I sort of feel we can do better, as ComprehensiveReleases have an array
// of the relevant changesets but since we need the version type for the
// release in the changeset, I don't know if we can
// We can filter here, but that just adds another iteration over this list
changesets.forEach((cs) => {
const rls = cs.releases.find((r) => r.name === release.name);
if (rls && rls.type !== "none") {
changelogLines[rls.type].push(
changelogFuncs.getReleaseLine(cs, rls.type, changelogOpts)
);
}
});
let dependentReleases = releases.filter((rel) => {
const dependencyVersionRange = release.packageJson.dependencies?.[rel.name];
const peerDependencyVersionRange =
release.packageJson.peerDependencies?.[rel.name];
const versionRange = dependencyVersionRange || peerDependencyVersionRange;
return (
versionRange &&
shouldUpdateDependencyBasedOnConfig(
{ type: rel.type, version: rel.newVersion },
{
depVersionRange: versionRange,
depType: dependencyVersionRange ? "dependencies" : "peerDependencies",
},
{
minReleaseType: updateInternalDependencies,
onlyUpdatePeerDependentsWhenOutOfRange,
}
)
);
});
let relevantChangesetIds: Set<string> = new Set();
dependentReleases.forEach((rel) => {
rel.changesets.forEach((cs) => {
relevantChangesetIds.add(cs);
});
});
let relevantChangesets = changesets.filter((cs) =>
relevantChangesetIds.has(cs.id)
);
changelogLines.patch.push(
changelogFuncs.getDependencyReleaseLine(
relevantChangesets,
dependentReleases,
changelogOpts
)
);
return [
`## ${release.newVersion}`,
await generateChangesForVersionTypeMarkdown(changelogLines, "major"),
await generateChangesForVersionTypeMarkdown(changelogLines, "minor"),
await generateChangesForVersionTypeMarkdown(changelogLines, "patch"),
]
.filter((line) => line)
.join("\n");
}