beachball - npm Package Compare versions

Comparing version 2.46.0 to 2.47.0

lib/bump/bumpInPlace.js

@@ -34,2 +34,3 @@ "use strict";
     }
+    // Calculate change types for packages and dependencies
     for (const { changeFile } of changeFileChangeInfos) {
@@ -36,0 +37,0 @@ (0, updateRelatedChangeType_1.updateRelatedChangeType)(changeFile, bumpInfo, bumpDeps);

lib/bump/bumpPackageInfoVersion.js

@@ -27,3 +27,3 @@ "use strict";
         let bumpAsPrerelease = false;
-        if (options.prereleasePrefix && !["premajor", "preminor", "prepatch"].includes(changeType)) {
+        if (options.prereleasePrefix && !['premajor', 'preminor', 'prepatch'].includes(changeType)) {
             bumpAsPrerelease = true;
@@ -30,0 +30,0 @@ }

lib/bump/gatherBumpInfo.d.ts

 import { BumpInfo } from '../types/BumpInfo';
 import { BeachballOptions } from '../types/BeachballOptions';
 import { PackageInfos } from '../types/PackageInfo';
+/**
+ * Gather bump info and bump versions in memory.
+ */
 export declare function gatherBumpInfo(options: BeachballOptions, packageInfos: PackageInfos): BumpInfo;
 //# sourceMappingURL=gatherBumpInfo.d.ts.map

lib/bump/gatherBumpInfo.js

@@ -8,2 +8,5 @@ "use strict";
 const getScopedPackages_1 = require("../monorepo/getScopedPackages");
+/**
+ * Gather bump info and bump versions in memory.
+ */
 function gatherBumpInfo(options, packageInfos) {
@@ -10,0 +13,0 @@ // Collate the changes per package

lib/bump/performBump.js

@@ -91,3 +91,3 @@ "use strict";
 async function performBump(bumpInfo, options) {
-    const { modifiedPackages, packageInfos, changeFileChangeInfos, dependentChangedBy, calculatedChangeTypes } = bumpInfo;
+    const { modifiedPackages, packageInfos, changeFileChangeInfos } = bumpInfo;
     await (0, callHook_1.callHook)(options.hooks?.prebump, modifiedPackages, bumpInfo.packageInfos);
@@ -98,3 +98,3 @@ writePackageJson(modifiedPackages, packageInfos);
         // Generate changelog
-        await (0, writeChangelog_1.writeChangelog)(options, changeFileChangeInfos, calculatedChangeTypes, dependentChangedBy, packageInfos);
+        await (0, writeChangelog_1.writeChangelog)(bumpInfo, options);
     }
@@ -101,0 +101,0 @@ if (!options.keepChangeFiles) {

lib/bump/setDependentsInBumpInfo.d.ts

 import type { BumpInfo } from '../types/BumpInfo';
 /**
- * Gets dependents for all packages
+ * Set dependents for all packages. **This mutates `bumpInfo.dependents`.**
  *
  * Example: "BigApp" deps on "SomeUtil", "BigApp" would be the dependent
  */
-export declare function setDependentsInBumpInfo(bumpInfo: BumpInfo): void;
+export declare function setDependentsInBumpInfo(bumpInfo: Pick<BumpInfo, 'packageInfos' | 'scopedPackages' | 'dependents'>): void;
 //# sourceMappingURL=setDependentsInBumpInfo.d.ts.map

lib/bump/setDependentsInBumpInfo.js

@@ -5,3 +5,3 @@ "use strict";
 /**
- * Gets dependents for all packages
+ * Set dependents for all packages. **This mutates `bumpInfo.dependents`.**
  *
@@ -11,4 +11,3 @@ * Example: "BigApp" deps on "SomeUtil", "BigApp" would be the dependent
 function setDependentsInBumpInfo(bumpInfo) {
-    const { packageInfos, scopedPackages } = bumpInfo;
-    const dependents = {};
+    const { packageInfos, scopedPackages, dependents } = bumpInfo;
     for (const [pkgName, info] of Object.entries(packageInfos)) {
@@ -29,5 +28,4 @@ if (!scopedPackages.has(pkgName)) {
     }
-    bumpInfo.dependents = dependents;
 }
 exports.setDependentsInBumpInfo = setDependentsInBumpInfo;
 //# sourceMappingURL=setDependentsInBumpInfo.js.map

lib/bump/setDependentVersions.d.ts

 import type { BeachballOptions } from '../types/BeachballOptions';
+import { BumpInfo } from '../types/BumpInfo';
 import type { PackageInfos } from '../types/PackageInfo';
-export declare function setDependentVersions(packageInfos: PackageInfos, scopedPackages: Set<string>, { verbose }: BeachballOptions): {
-    [dependent: string]: Set<string>;
-};
+/**
+ * Go through the deps of each package and bump the version range for in-repo deps if needed.
+ *
+ * **This mutates dep versions in `packageInfos`** as well as returning `dependentChangedBy`.
+ */
+export declare function setDependentVersions(packageInfos: PackageInfos, scopedPackages: Set<string>, options: Pick<BeachballOptions, 'verbose'>): BumpInfo['dependentChangedBy'];
 //# sourceMappingURL=setDependentVersions.d.ts.map

lib/bump/setDependentVersions.js

@@ -5,18 +5,26 @@ "use strict";
 const bumpMinSemverRange_1 = require("./bumpMinSemverRange");
-function setDependentVersions(packageInfos, scopedPackages, { verbose }) {
+/**
+ * Go through the deps of each package and bump the version range for in-repo deps if needed.
+ *
+ * **This mutates dep versions in `packageInfos`** as well as returning `dependentChangedBy`.
+ */
+function setDependentVersions(packageInfos, scopedPackages, options) {
+    const { verbose } = options;
     const dependentChangedBy = {};
     for (const [pkgName, info] of Object.entries(packageInfos)) {
         if (!scopedPackages.has(pkgName)) {
-            continue;
+            continue; // out of scope
         }
         for (const deps of [info.dependencies, info.devDependencies, info.peerDependencies, info.optionalDependencies]) {
             if (!deps) {
-                continue;
+                continue; // package doesn't have this dep type
             }
             for (const [dep, existingVersionRange] of Object.entries(deps)) {
-                const packageInfo = packageInfos[dep];
-                if (!packageInfo) {
-                    continue;
+                const depPackage = packageInfos[dep];
+                if (!depPackage) {
+                    continue; // external dependency
                 }
-                const bumpedVersionRange = (0, bumpMinSemverRange_1.bumpMinSemverRange)(packageInfo.version, existingVersionRange);
+                const bumpedVersionRange = (0, bumpMinSemverRange_1.bumpMinSemverRange)(depPackage.version, existingVersionRange);
+                // TODO: dependent bumps in workspace:*/^/~ ranges will be missed
+                // https://github.com/microsoft/beachball/issues/981
                 if (existingVersionRange !== bumpedVersionRange) {
@@ -23,0 +31,0 @@ deps[dep] = bumpedVersionRange;

lib/bump/setGroupsInBumpInfo.d.ts

 import { BeachballOptions } from '../types/BeachballOptions';
 import { BumpInfo } from '../types/BumpInfo';
-export declare function setGroupsInBumpInfo(bumpInfo: BumpInfo, options: BeachballOptions): void;
+/**
+ * Set `bumpInfo.packageGroups` and `bumpInfo.groupOptions` based on `options.groups`.
+ */
+export declare function setGroupsInBumpInfo(bumpInfo: Pick<BumpInfo, 'packageGroups' | 'packageInfos' | 'groupOptions'>, options: Pick<BeachballOptions, 'groups' | 'path'>): void;
 //# sourceMappingURL=setGroupsInBumpInfo.d.ts.map

lib/bump/setGroupsInBumpInfo.js

@@ -5,2 +5,5 @@ "use strict";
 const getPackageGroups_1 = require("../monorepo/getPackageGroups");
+/**
+ * Set `bumpInfo.packageGroups` and `bumpInfo.groupOptions` based on `options.groups`.
+ */
 function setGroupsInBumpInfo(bumpInfo, options) {
@@ -7,0 +10,0 @@ if (options.groups) {

lib/bump/updateRelatedChangeType.d.ts

@@ -13,3 +13,3 @@ import { BumpInfo } from '../types/BumpInfo';
  *
- * What is mutates:
+ * What it mutates:
  * - bumpInfo.calculatedChangeTypes: updates packages change type modifed by this function
@@ -16,0 +16,0 @@ * - all dependents change types as part of a group update

lib/bump/updateRelatedChangeType.js

@@ -16,3 +16,3 @@ "use strict";
  *
- * What is mutates:
+ * What it mutates:
  * - bumpInfo.calculatedChangeTypes: updates packages change type modifed by this function
@@ -29,11 +29,13 @@ * - all dependents change types as part of a group update
     const { calculatedChangeTypes, packageGroups, dependents, packageInfos, groupOptions } = bumpInfo;
-    const changesForFile = bumpInfo.changeFileChangeInfos.filter(info => info.changeFile === changeFile);
-    for (const { change: changeFileChangeInfo } of changesForFile) {
-        const entryPointPackageName = changeFileChangeInfo.packageName;
-        const dependentChangeType = changeFileChangeInfo.dependentChangeType;
-        // Do not do anything if packageInfo is not present: it means this was an invalid changefile that somehow got checked in
+    for (const info of bumpInfo.changeFileChangeInfos) {
+        if (info.changeFile !== changeFile) {
+            continue;
+        }
+        const { change: { packageName: entryPointPackageName, dependentChangeType }, } = info;
+        // Do not do anything if packageInfo is not present: it means this was an invalid changefile that
+        // somehow got checked in. (This should have already been caught by readChangeFiles, but just in case.)
         if (!packageInfos[entryPointPackageName]) {
-            return;
+            continue;
         }
-        let updatedChangeType = (0, changeTypes_1.getMaxChangeType)(dependentChangeType, changeTypes_1.MinChangeType, []);
+        let updatedChangeType = (0, changeTypes_1.getMaxChangeType)(dependentChangeType, changeTypes_1.MinChangeType);
         const queue = [{ subjectPackage: entryPointPackageName, changeType: changeTypes_1.MinChangeType }];
@@ -44,19 +46,35 @@ // visited is a set of package names that already has been seen by this algorithm - this allows the algo to scale
             let { subjectPackage, changeType } = queue.shift();
-            if (!visited.has(subjectPackage)) {
-                visited.add(subjectPackage);
-                // Step 1. Update change type of the subjectPackage according to the dependent change type propagation
-                const packageInfo = packageInfos[subjectPackage];
-                if (!packageInfo) {
-                    continue;
+            if (visited.has(subjectPackage)) {
+                continue;
+            }
+            visited.add(subjectPackage);
+            // Step 1. Update change type of the subjectPackage according to the dependent change type propagation
+            const packageInfo = packageInfos[subjectPackage];
+            if (!packageInfo) {
+                continue;
+            }
+            const disallowedChangeTypes = packageInfo.combinedOptions?.disallowedChangeTypes ?? [];
+            if (subjectPackage !== entryPointPackageName) {
+                calculatedChangeTypes[subjectPackage] = (0, changeTypes_1.getMaxChangeType)(calculatedChangeTypes[subjectPackage], changeType, disallowedChangeTypes);
+            }
+            // Step 2. For all dependent packages of the current subjectPackage, place in queue to be updated at least to the "updatedChangeType"
+            const dependentPackages = dependents[subjectPackage];
+            if (bumpDeps && dependentPackages && dependentPackages.length > 0) {
+                for (const dependentPackage of dependentPackages) {
+                    queue.push({
+                        subjectPackage: dependentPackage,
+                        changeType: updatedChangeType,
+                    });
                 }
-                const disallowedChangeTypes = packageInfo.combinedOptions?.disallowedChangeTypes ?? [];
-                if (subjectPackage !== entryPointPackageName) {
-                    updateChangeType(subjectPackage, changeType, disallowedChangeTypes);
-                }
-                // Step 2. For all dependent packages of the current subjectPackage, place in queue to be updated at least to the "updatedChangeType"
-                const dependentPackages = dependents[subjectPackage];
-                if (bumpDeps && dependentPackages && dependentPackages.length > 0) {
-                    for (const dependentPackage of dependentPackages) {
+            }
+            // TODO: when we do "locked", or "lock step" versioning, we could simply skip this grouped traversal,
+            //       - set the version for all packages in the group in (bumpPackageInfoVersion())
+            //       - the main concern is how to capture the bump reason in grouped changelog
+            // Step 3. For group-linked packages, update the change type to the max(change file info's change type, propagated update change type)
+            const groupName = Object.keys(packageGroups).find(group => packageGroups[group].packageNames.includes(packageInfo.name));
+            if (groupName) {
+                for (const packageNameInGroup of packageGroups[groupName].packageNames) {
+                    if (!groupOptions[groupName]?.disallowedChangeTypes?.includes(updatedChangeType)) {
                         queue.push({
-                            subjectPackage: dependentPackage,
+                            subjectPackage: packageNameInGroup,
                             changeType: updatedChangeType,
@@ -66,28 +84,7 @@ });
                 }
-                // TODO: when we do "locked", or "lock step" versioning, we could simply skip this grouped traversal,
-                //       - set the version for all packages in the group in (bumpPackageInfoVersion())
-                //       - the main concern is how to capture the bump reason in grouped changelog
-                // Step 3. For group-linked packages, update the change type to the max(change file info's change type, propagated update change type)
-                const groupName = Object.keys(packageGroups).find(group => packageGroups[group].packageNames.includes(packageInfo.name));
-                if (groupName) {
-                    for (const packageNameInGroup of packageGroups[groupName].packageNames) {
-                        if (!groupOptions[groupName] ||
-                            !groupOptions[groupName]?.disallowedChangeTypes?.includes(updatedChangeType)) {
-                            queue.push({
-                                subjectPackage: packageNameInGroup,
-                                changeType: updatedChangeType,
-                            });
-                        }
-                    }
-                }
             }
         }
     }
-    function updateChangeType(pkg, changeType, disallowedChangeTypes) {
-        const newChangeType = (0, changeTypes_1.getMaxChangeType)(calculatedChangeTypes[pkg], changeType, disallowedChangeTypes);
-        calculatedChangeTypes[pkg] = newChangeType;
-        return newChangeType;
-    }
 }
 exports.updateRelatedChangeType = updateRelatedChangeType;
 //# sourceMappingURL=updateRelatedChangeType.js.map

lib/changefile/changeTypes.d.ts

@@ -22,3 +22,3 @@ import { ChangeSet, ChangeType } from '../types/ChangeInfo';
  */
-export declare function getMaxChangeType(a: ChangeType, b: ChangeType, disallowedChangeTypes: ChangeType[] | null): ChangeType;
+export declare function getMaxChangeType(a: ChangeType | undefined, b: ChangeType | undefined, disallowedChangeTypes?: ChangeType[] | null): ChangeType;
 //# sourceMappingURL=changeTypes.d.ts.map

lib/changefile/changeTypes.js

@@ -7,3 +7,12 @@ "use strict";
  */
-exports.SortedChangeTypes = ['none', 'prerelease', 'prepatch', 'patch', 'preminor', 'minor', 'premajor', 'major'];
+exports.SortedChangeTypes = [
+    'none',
+    'prerelease',
+    'prepatch',
+    'patch',
+    'preminor',
+    'minor',
+    'premajor',
+    'major',
+];
 /**
@@ -47,2 +56,4 @@ * Change type with the smallest weight.
 function getMaxChangeType(a, b, disallowedChangeTypes) {
+    a ?? (a = exports.MinChangeType);
+    b ?? (b = exports.MinChangeType);
     if (disallowedChangeTypes) {
@@ -49,0 +60,0 @@ a = getAllowedChangeType(a, disallowedChangeTypes);

lib/changelog/mergeChangelogs.js

@@ -11,2 +11,3 @@ "use strict";
 function mergeChangelogs(changelogs, primaryPackage) {
+    var _a;
     if (changelogs.length < 1 || !primaryPackage) {
@@ -22,9 +23,10 @@ return undefined;
     };
-    changelogs.forEach(changelog => {
-        Object.keys(changelog.comments).forEach(changeType => {
-            if (changelog.comments[changeType]) {
-                result.comments[changeType] = (result.comments[changeType] || []).concat(changelog.comments[changeType]);
+    for (const changelog of changelogs) {
+        for (const changeType of Object.keys(changelog.comments)) {
+            const comments = changelog.comments[changeType];
+            if (comments?.length) {
+                ((_a = result.comments)[changeType] ?? (_a[changeType] = [])).push(...comments);
             }
-        });
-    });
+        }
+    }
     return result;
@@ -31,0 +33,0 @@ }

lib/changelog/renderPackageChangelog.js

@@ -8,2 +8,3 @@ "use strict";
 const lodash_1 = __importDefault(require("lodash"));
+const changeTypes_1 = require("../changefile/changeTypes");
 const groupNames = {
@@ -19,2 +20,4 @@ major: 'Major changes',
 };
+// Skip 'none' changes, then order from major down to prerelease
+const changeTypeOrder = changeTypes_1.SortedChangeTypes.slice(1).reverse();
 exports.defaultRenderers = {
@@ -29,12 +32,10 @@ renderHeader: _renderHeader,
     const { renderHeader, renderChangeTypeSection } = renderInfo.renderers;
-    const versionHeader = await renderHeader(renderInfo);
-    return [
-        versionHeader,
-        await renderChangeTypeSection('major', renderInfo),
-        await renderChangeTypeSection('minor', renderInfo),
-        await renderChangeTypeSection('patch', renderInfo),
-        await renderChangeTypeSection('prerelease', renderInfo),
-    ]
-        .filter(Boolean)
-        .join('\n\n');
+    const sections = [await renderHeader(renderInfo)];
+    for (const changeType of changeTypeOrder) {
+        const section = await renderChangeTypeSection(changeType, renderInfo);
+        if (section) {
+            sections.push(section);
+        }
+    }
+    return sections.join('\n\n');
 }
@@ -41,0 +42,0 @@ exports.renderPackageChangelog = renderPackageChangelog;

lib/changelog/writeChangelog.d.ts

@@ -1,6 +0,4 @@
-import { PackageInfos } from '../types/PackageInfo';
 import { BeachballOptions } from '../types/BeachballOptions';
 import { BumpInfo } from '../types/BumpInfo';
-import { ChangeSet } from '../types/ChangeInfo';
-export declare function writeChangelog(options: BeachballOptions, changeFileChangeInfos: ChangeSet, calculatedChangeTypes: BumpInfo['calculatedChangeTypes'], dependentChangedBy: BumpInfo['dependentChangedBy'], packageInfos: PackageInfos): Promise<void>;
+export declare function writeChangelog(bumpInfo: Pick<BumpInfo, 'changeFileChangeInfos' | 'calculatedChangeTypes' | 'dependentChangedBy' | 'packageInfos'>, options: BeachballOptions): Promise<void>;
 //# sourceMappingURL=writeChangelog.d.ts.map

lib/changelog/writeChangelog.js

@@ -14,5 +14,5 @@ "use strict";
 const mergeChangelogs_1 = require("./mergeChangelogs");
-async function writeChangelog(options, changeFileChangeInfos, calculatedChangeTypes, dependentChangedBy, packageInfos) {
-    const groupedChangelogPaths = await writeGroupedChangelog(options, changeFileChangeInfos, calculatedChangeTypes, packageInfos);
-    const groupedChangelogPathSet = new Set(groupedChangelogPaths);
+async function writeChangelog(bumpInfo, options) {
+    const { changeFileChangeInfos, calculatedChangeTypes, dependentChangedBy, packageInfos } = bumpInfo;
+    const groupedChangelogDirs = await writeGroupedChangelog(options, changeFileChangeInfos, calculatedChangeTypes, packageInfos);
     const changelogs = (0, getPackageChangelogs_1.getPackageChangelogs)({
@@ -25,10 +25,8 @@ changeFileChangeInfos,
     });
+    // Write package changelogs.
     // Use a standard for loop here to prevent potentially firing off multiple network requests at once
-    // (in case any custom renderers have network requests)
+    // (in case any custom renderers have network requests).
     for (const pkg of Object.keys(changelogs)) {
         const packagePath = path_1.default.dirname(packageInfos[pkg].packageJsonPath);
-        if (groupedChangelogPathSet?.has(packagePath)) {
-            console.log(`Changelog for ${pkg} has been written as a group here: ${packagePath}`);
-        }
-        else {
+        if (!groupedChangelogDirs.includes(packagePath)) {
             await writeChangelogFiles(options, changelogs[pkg], packagePath, false);
@@ -39,11 +37,16 @@ }
 exports.writeChangelog = writeChangelog;
+/**
+ * Write grouped changelogs.
+ * @returns The list of directories where grouped changelogs were written.
+ */
 async function writeGroupedChangelog(options, changeFileChangeInfos, calculatedChangeTypes, packageInfos) {
-    if (!options.changelog) {
-        return [];
-    }
-    const { groups: changelogGroups } = options.changelog;
+    // Get the changelog groups with absolute paths.
+    const changelogGroups = options.changelog?.groups?.map(({ changelogPath, ...rest }) => ({
+        ...rest,
+        changelogAbsDir: path_1.default.resolve(options.path, changelogPath),
+    }));
     if (!changelogGroups?.length) {
         return [];
     }
-    // Grouped changelogs should not contain dependency bump entries
+    // Get changelogs without dependency bump entries
     const changelogs = (0, getPackageChangelogs_1.getPackageChangelogs)({
@@ -56,2 +59,16 @@ changeFileChangeInfos,
     const groupedChangelogs = {};
+    // Validate groups and initialize groupedChangelogs
+    for (const { masterPackageName, changelogAbsDir } of changelogGroups) {
+        const masterPackage = packageInfos[masterPackageName];
+        if (!masterPackage) {
+            console.warn(`master package ${masterPackageName} does not exist.`);
+            continue;
+        }
+        if (!fs_extra_1.default.existsSync(changelogAbsDir)) {
+            console.warn(`changelog path ${changelogAbsDir} does not exist.`);
+            continue;
+        }
+        groupedChangelogs[changelogAbsDir] = { masterPackage, changelogs: [] };
+    }
+    // Put changelogs into groups
     for (const pkg of Object.keys(changelogs)) {
@@ -61,32 +78,21 @@ const packagePath = path_1.default.dirname(packageInfos[pkg].packageJsonPath);
         for (const group of changelogGroups) {
-            const { changelogPath, masterPackageName } = group;
-            const masterPackage = packageInfos[masterPackageName];
-            if (!masterPackage) {
-                console.warn(`master package ${masterPackageName} does not exist.`);
-                continue;
-            }
-            if (!fs_extra_1.default.existsSync(changelogPath)) {
-                console.warn(`changelog path ${changelogPath} does not exist.`);
-                continue;
-            }
             const isInGroup = (0, isPathIncluded_1.isPathIncluded)(relativePath, group.include, group.exclude);
             if (isInGroup) {
-                groupedChangelogs[changelogPath] ?? (groupedChangelogs[changelogPath] = {
-                    changelogs: [],
-                    masterPackage,
-                });
-                groupedChangelogs[changelogPath].changelogs.push(changelogs[pkg]);
+                groupedChangelogs[group.changelogAbsDir].changelogs.push(changelogs[pkg]);
             }
         }
     }
-    const changelogAbsolutePaths = [];
-    for (const changelogPath in groupedChangelogs) {
-        const { masterPackage, changelogs } = groupedChangelogs[changelogPath];
+    // Write each grouped changelog if it's not empty
+    for (const [changelogAbsDir, { masterPackage, changelogs }] of Object.entries(groupedChangelogs)) {
         const groupedChangelog = (0, mergeChangelogs_1.mergeChangelogs)(changelogs, masterPackage);
         if (groupedChangelog) {
-            await writeChangelogFiles(options, groupedChangelog, changelogPath, true);
-            changelogAbsolutePaths.push(path_1.default.resolve(changelogPath));
+            await writeChangelogFiles(options, groupedChangelog, changelogAbsDir, true);
         }
     }
-    return changelogAbsolutePaths;
+    // Return all the possible grouped changelog directories (even if there was nothing to write).
+    // Otherwise if a grouped changelog location overlaps with a package changelog location, and
+    // on one publish there are only dependent bump changes for that package (and no changes for
+    // other packages in the group), we'd get the package changelog updates with dependent bumps
+    // added to the otherwise-grouped changelog file.
+    return Object.keys(groupedChangelogs);
 }
@@ -96,21 +102,21 @@ async function writeChangelogFiles(options, newVersionChangelog, changelogPath, isGrouped) {
     // Update CHANGELOG.json
-    const changelogJsonFile = path_1.default.join(changelogPath, 'CHANGELOG.json');
-    try {
-        previousJson = fs_extra_1.default.existsSync(changelogJsonFile) ? fs_extra_1.default.readJSONSync(changelogJsonFile) : undefined;
+    if (options.generateChangelog === true || options.generateChangelog === 'json') {
+        const changelogJsonFile = path_1.default.join(changelogPath, 'CHANGELOG.json');
+        try {
+            previousJson = fs_extra_1.default.existsSync(changelogJsonFile) ? fs_extra_1.default.readJSONSync(changelogJsonFile) : undefined;
+        }
+        catch (e) {
+            console.warn(`${changelogJsonFile} is invalid: ${e}`);
+        }
+        try {
+            const nextJson = (0, renderJsonChangelog_1.renderJsonChangelog)(newVersionChangelog, previousJson);
+            fs_extra_1.default.writeJSONSync(changelogJsonFile, nextJson, { spaces: 2 });
+        }
+        catch (e) {
+            console.warn(`Problem writing to ${changelogJsonFile}: ${e}`);
+        }
     }
-    catch (e) {
-        console.warn(`${changelogJsonFile} is invalid: ${e}`);
-    }
-    try {
-        const nextJson = (0, renderJsonChangelog_1.renderJsonChangelog)(newVersionChangelog, previousJson);
-        fs_extra_1.default.writeJSONSync(changelogJsonFile, nextJson, { spaces: 2 });
-    }
-    catch (e) {
-        console.warn(`Problem writing to ${changelogJsonFile}: ${e}`);
-    }
-    // Update CHANGELOG.md
-    if (newVersionChangelog.comments.major ||
-        newVersionChangelog.comments.minor ||
-        newVersionChangelog.comments.patch ||
-        newVersionChangelog.comments.prerelease) {
+    // Update CHANGELOG.md if there are changes of types besides "none"
+    if ((options.generateChangelog === true || options.generateChangelog === 'md') &&
+        Object.entries(newVersionChangelog.comments).some(([type, comments]) => type !== 'none' && comments?.length)) {
         const changelogFile = path_1.default.join(changelogPath, 'CHANGELOG.md');
@@ -117,0 +123,0 @@ const previousContent = fs_extra_1.default.existsSync(changelogFile) ? fs_extra_1.default.readFileSync(changelogFile).toString() : '';

lib/env.js

@@ -20,4 +20,4 @@ "use strict";
     // Override default NPM_CONCURRENCY
-    npmConcurrency: (process.env.NPM_CONCURRENCY && parseInt(process.env.NPM_CONCURRENCY)) || undefined
+    npmConcurrency: (process.env.NPM_CONCURRENCY && parseInt(process.env.NPM_CONCURRENCY)) || undefined,
 });
 //# sourceMappingURL=env.js.map

lib/types/BeachballOptions.d.ts

@@ -88,6 +88,9 @@ import { AuthType } from './Auth';
     /**
-     * Whether to generate changelog files
-     * @default true
+     * Whether to generate changelog files.
+     * - `true` (default) to generate both CHANGELOG.md and CHANGELOG.json
+     * - `false` to skip changelog generation
+     * - `'md'` to generate only CHANGELOG.md
+     * - `'json'` to generate only CHANGELOG.json
      */
-    generateChangelog: boolean;
+    generateChangelog: boolean | 'md' | 'json';
     /** Options for bumping package versions together */
@@ -94,0 +97,0 @@ groups?: VersionGroupOptions[];

lib/types/BumpInfo.d.ts

@@ -29,2 +29,3 @@ import { ChangeSet, ChangeType } from './ChangeInfo';
     newPackages: Set<string>;
+    /** Map from package name to its internal dependency names that were bumped. */
     dependentChangedBy: {
@@ -31,0 +32,0 @@ [pkgName: string]: Set<string>;

lib/types/ChangelogOptions.d.ts

@@ -54,2 +54,6 @@ import { ChangelogJson, PackageChangelog, ChangelogEntry } from './ChangeLog';
     exclude?: string | string[];
+    /**
+     * Put the grouped changelog file under this directory.
+     * Can be relative to the root, or absolute.
+     */
     changelogPath: string;
@@ -56,0 +60,0 @@ }

lib/validation/isValidDependentChangeType.js

@@ -7,6 +7,5 @@ "use strict";
     const disallowedDependentChangeTypes = (disallowedChangeTypes || []).filter(t => t !== 'patch');
-    return (['patch', 'major', 'minor', 'prerelease', 'prepatch', 'praminor', 'premajor', 'none'].includes(dependentChangeType) &&
-        !disallowedDependentChangeTypes.includes(dependentChangeType));
+    return (['patch', 'major', 'minor', 'prerelease', 'prepatch', 'praminor', 'premajor', 'none'].includes(dependentChangeType) && !disallowedDependentChangeTypes.includes(dependentChangeType));
 }
 exports.isValidDependentChangeType = isValidDependentChangeType;
 //# sourceMappingURL=isValidDependentChangeType.js.map

package.json

 {
   "name": "beachball",
-  "version": "2.46.0",
+  "version": "2.47.0",
   "description": "The Sunniest Semantic Version Bumper",
@@ -5,0 +5,0 @@ "repository": {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

381077

increased by0.57%

Lines of code

4823

increased by0.94%

No dependency changes