release-please 16.5.1 → 16.7.0

package/build/src/index.d.ts

@@ -14,4 +14,4 @@ export { Logger, setLogger } from './util/logger';
 export { GitHub } from './github';
 export declare const configSchema: any;
 export declare const manifestSchema: any;
-export declare const VERSION = "16.5.1";
+export declare const VERSION = "16.7.0";

package/build/src/index.js

@@ -36,6 +36,6 @@ Object.defineProperty(exports, "GitHub", { enumerable: true, get: function () {
 exports.configSchema = require('../../schemas/config.json');
 exports.manifestSchema = require('../../schemas/manifest.json');
 // x-release-please-start-version
-exports.VERSION = '16.5.1';
+exports.VERSION = '16.7.0';
 // x-release-please-end
 //# sourceMappingURL=index.js.map

package/build/src/plugins/cargo-workspace.d.ts

@@ -42,7 +42,7 @@ export declare class CargoWorkspace extends WorkspacePlugin<CrateInfo> {
     }>;
     protected bumpVersion(pkg: CrateInfo): Version;
     protected updateCandidate(existingCandidate: CandidateReleasePullRequest, pkg: CrateInfo, updatedVersions: VersionsMap): CandidateReleasePullRequest;
-    protected newCandidate(pkg: CrateInfo, updatedVersions: VersionsMap): CandidateReleasePullRequest;
+    protected newCandidate(pkg: CrateInfo, updatedVersions: VersionsMap): Promise<CandidateReleasePullRequest>;
     protected postProcessCandidates(candidates: CandidateReleasePullRequest[], updatedVersions: VersionsMap): CandidateReleasePullRequest[];
     protected buildGraph(allPackages: CrateInfo[]): Promise<DependencyGraph<CrateInfo>>;
     protected inScope(candidate: CandidateReleasePullRequest): boolean;

package/build/src/plugins/cargo-workspace.js

@@ -130,7 +130,7 @@ class CargoWorkspace extends workspace_1.WorkspacePlugin {
         }
         return existingCandidate;
     }
-    newCandidate(pkg, updatedVersions) {
+    async newCandidate(pkg, updatedVersions) {
         const version = updatedVersions.get(pkg.name);
         if (!version) {
             throw new Error(`Didn't find updated version for ${pkg.name}`);

package/build/src/plugins/maven-workspace.d.ts

@@ -72,7 +72,7 @@ export declare class MavenWorkspace extends WorkspacePlugin<MavenArtifact> {
     protected isReleaseVersion(version: Version): boolean;
     protected bumpVersion(artifact: MavenArtifact): Version;
     protected updateCandidate(existingCandidate: CandidateReleasePullRequest, artifact: MavenArtifact, updatedVersions: VersionsMap): CandidateReleasePullRequest;
-    protected newCandidate(artifact: MavenArtifact, updatedVersions: VersionsMap): CandidateReleasePullRequest;
+    protected newCandidate(artifact: MavenArtifact, updatedVersions: VersionsMap): Promise<CandidateReleasePullRequest>;
     protected inScope(candidate: CandidateReleasePullRequest): boolean;
     protected packageNameFromPackage(artifact: MavenArtifact): string;
     protected pathFromPackage(artifact: MavenArtifact): string;

package/build/src/plugins/maven-workspace.js

@@ -266,7 +266,7 @@ class MavenWorkspace extends workspace_1.WorkspacePlugin {
         }
         return existingCandidate;
     }
-    newCandidate(artifact, updatedVersions) {
+    async newCandidate(artifact, updatedVersions) {
         const version = updatedVersions.get(artifact.name);
         if (!version) {
             throw new Error(`Didn't find updated version for ${artifact.name}`);

package/build/src/plugins/node-workspace.d.ts

@@ -2,6 +2,9 @@ import { GitHub } from '../github';
 import { CandidateReleasePullRequest, RepositoryConfig } from '../manifest';
 import { Version, VersionsMap } from '../version';
 import { WorkspacePlugin, DependencyGraph, WorkspacePluginOptions } from './workspace';
+import { Strategy } from '../strategy';
+import { Commit } from '../commit';
+import { Release } from '../release';
 interface Package {
     path: string;
     name: string;
@@ -25,6 +28,8 @@ interface NodeWorkspaceOptions extends WorkspacePluginOptions {
  */
 export declare class NodeWorkspace extends WorkspacePlugin<Package> {
     private alwaysLinkLocal;
+    private strategiesByPath;
+    private releasesByPath;
     readonly updatePeerDependencies: boolean;
     constructor(github: GitHub, targetBranch: string, repositoryConfig: RepositoryConfig, options?: NodeWorkspaceOptions);
     protected buildAllPackages(candidates: CandidateReleasePullRequest[]): Promise<{
@@ -33,12 +38,13 @@ export declare class NodeWorkspace extends WorkspacePlugin<Package> {
     }>;
     protected bumpVersion(pkg: Package): Version;
     protected updateCandidate(existingCandidate: CandidateReleasePullRequest, pkg: Package, updatedVersions: VersionsMap): CandidateReleasePullRequest;
-    protected newCandidate(pkg: Package, updatedVersions: VersionsMap): CandidateReleasePullRequest;
+    protected newCandidate(pkg: Package, updatedVersions: VersionsMap): Promise<CandidateReleasePullRequest>;
     protected postProcessCandidates(candidates: CandidateReleasePullRequest[], _updatedVersions: VersionsMap): CandidateReleasePullRequest[];
     protected buildGraph(allPackages: Package[]): Promise<DependencyGraph<Package>>;
     protected inScope(candidate: CandidateReleasePullRequest): boolean;
     protected packageNameFromPackage(pkg: Package): string;
     protected pathFromPackage(pkg: Package): string;
     private combineDeps;
+    preconfigure(strategiesByPath: Record<string, Strategy>, _commitsByPath: Record<string, Commit[]>, _releasesByPath: Record<string, Release>): Promise<Record<string, Strategy>>;
 }
 export {};

package/build/src/plugins/node-workspace.js

@@ -14,6 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeWorkspace = void 0;
+const package_lock_json_1 = require("../updaters/node/package-lock-json");
 const version_1 = require("../version");
 const pull_request_title_1 = require("../util/pull-request-title");
 const pull_request_body_1 = require("../util/pull-request-body");
@@ -33,6 +34,8 @@ const package_json_1 = require("../updaters/node/package-json");
 class NodeWorkspace extends workspace_1.WorkspacePlugin {
     constructor(github, targetBranch, repositoryConfig, options = {}) {
         super(github, targetBranch, repositoryConfig, options);
+        this.strategiesByPath = {};
+        this.releasesByPath = {};
         this.alwaysLinkLocal = options.alwaysLinkLocal === false ? false : true;
         this.updatePeerDependencies = options.updatePeerDependencies === true;
     }
@@ -118,6 +121,12 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
                 if (update.path === (0, workspace_1.addPath)(existingCandidate.path, 'package.json')) {
                     update.updater = new composite_1.CompositeUpdater(update.updater, updater);
                 }
+                else if (update.path === (0, workspace_1.addPath)(existingCandidate.path, 'package-lock.json')) {
+                    update.updater = new package_lock_json_1.PackageLockJson({
+                        version: newVersion,
+                        versionsMap: updatedVersions,
+                    });
+                }
                 else if (update.updater instanceof changelog_1.Changelog) {
                     if (dependencyNotes) {
                         update.updater.changelogEntry =
@@ -142,7 +151,7 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
         }
         return existingCandidate;
     }
-    newCandidate(pkg, updatedVersions) {
+    async newCandidate(pkg, updatedVersions) {
         // Update version of the package
         const newVersion = updatedVersions.get(pkg.name);
         if (!newVersion) {
@@ -153,6 +162,22 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
             version: newVersion.toString(),
         };
         const dependencyNotes = getChangelogDepsNotes(pkg, updatedPackage, updatedVersions, this.logger);
+        const strategy = this.strategiesByPath[updatedPackage.path];
+        const latestRelease = this.releasesByPath[updatedPackage.path];
+        const basePullRequest = strategy
+            ? await strategy.buildReleasePullRequest([], latestRelease, false, [], {
+                newVersion,
+            })
+            : undefined;
+        if (basePullRequest) {
+            return this.updateCandidate({
+                path: pkg.path,
+                pullRequest: basePullRequest,
+                config: {
+                    releaseType: 'node',
+                },
+            }, pkg, updatedVersions);
+        }
         const pullRequest = {
             title: pull_request_title_1.PullRequestTitle.ofTargetBranch(this.targetBranch),
             body: new pull_request_body_1.PullRequestBody([
@@ -171,6 +196,14 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
                         versionsMap: updatedVersions,
                     }),
                 },
+                {
+                    path: (0, workspace_1.addPath)(updatedPackage.path, 'package-lock.json'),
+                    createIfMissing: false,
+                    updater: new package_json_1.PackageJson({
+                        version: newVersion,
+                        versionsMap: updatedVersions,
+                    }),
+                },
                 {
                     path: (0, workspace_1.addPath)(updatedPackage.path, 'CHANGELOG.md'),
                     createIfMissing: false,
@@ -194,7 +227,32 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
         };
     }
     postProcessCandidates(candidates, _updatedVersions) {
-        // NOP for node workspaces
+        if (candidates.length === 0) {
+            return candidates;
+        }
+        const [candidate] = candidates;
+        // check for root lock file in pull request
+        let hasRootLockFile;
+        for (let i = 0; i < candidate.pullRequest.updates.length; i++) {
+            if (candidate.pullRequest.updates[i].path === '.package-lock.json' ||
+                candidate.pullRequest.updates[i].path === './package-lock.json' ||
+                candidate.pullRequest.updates[i].path === 'package-lock.json' ||
+                candidate.pullRequest.updates[i].path === '/package-lock.json') {
+                hasRootLockFile = true;
+                break;
+            }
+        }
+        // if there is a root lock file, then there is no additional pull request update necessary.
+        if (hasRootLockFile) {
+            return candidates;
+        }
+        candidate.pullRequest.updates.push({
+            path: 'package-lock.json',
+            createIfMissing: false,
+            updater: new package_lock_json_1.PackageLockJson({
+                versionsMap: _updatedVersions,
+            }),
+        });
         return candidates;
     }
     async buildGraph(allPackages) {
@@ -230,6 +288,12 @@ class NodeWorkspace extends workspace_1.WorkspacePlugin {
                 : {}),
         };
     }
+    async preconfigure(strategiesByPath, _commitsByPath, _releasesByPath) {
+        // Using preconfigure to siphon releases and strategies.
+        this.strategiesByPath = strategiesByPath;
+        this.releasesByPath = _releasesByPath;
+        return strategiesByPath;
+    }
 }
 exports.NodeWorkspace = NodeWorkspace;
 function getChangelogDepsNotes(original, updated, updateVersions, logger) {

package/build/src/plugins/workspace.d.ts

@@ -105,7 +105,7 @@ export declare abstract class WorkspacePlugin<T> extends ManifestPlugin {
      *   update.
      * @returns {CandidateReleasePullRequest} A new pull request
      */
-    protected abstract newCandidate(pkg: T, updatedVersions: VersionsMap): CandidateReleasePullRequest;
+    protected abstract newCandidate(pkg: T, updatedVersions: VersionsMap): Promise<CandidateReleasePullRequest>;
     /**
      * Collect all packages being managed in this workspace.
      * @param {CanididateReleasePullRequest[]} candidates Existing candidate pull

package/build/src/plugins/workspace.js

@@ -86,7 +86,7 @@ class WorkspacePlugin extends plugin_1.ManifestPlugin {
             else {
                 // otherwise, build a new pull request with changelog and entry update
                 this.logger.info(`Creating new candidate pull request for ${this.packageNameFromPackage(pkg)}`);
-                const newCandidate = this.newCandidate(pkg, updatedVersions);
+                const newCandidate = await this.newCandidate(pkg, updatedVersions);
                 if (newCandidatePaths.has(newCandidate.path)) {
                     this.logger.info(`Already created new candidate for path: ${newCandidate.path}`);
                 }

package/build/src/strategies/base.d.ts

@@ -1,4 +1,4 @@
-import { Strategy, BuildReleaseOptions } from '../strategy';
+import { Strategy, BuildReleaseOptions, BumpReleaseOptions } from '../strategy';
 import { GitHub } from '../github';
 import { VersioningStrategy } from '../versioning-strategy';
 import { Repository } from '../repository';
@@ -115,7 +115,7 @@ export declare abstract class BaseStrategy implements Strategy {
      *   open for this path/component. Returns undefined if we should not
      *   open a pull request.
      */
-    buildReleasePullRequest(commits: ConventionalCommit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    buildReleasePullRequest(commits: ConventionalCommit[], latestRelease?: Release, draft?: boolean, labels?: string[], bumpOnlyOptions?: BumpReleaseOptions): Promise<ReleasePullRequest | undefined>;
     private extraFilePaths;
     protected extraFileUpdates(version: Version, versionsMap: VersionsMap): Promise<Update[]>;
     protected changelogEmpty(changelogEntry: string): boolean;

package/build/src/strategies/base.js

@@ -142,14 +142,15 @@ class BaseStrategy {
      *   open for this path/component. Returns undefined if we should not
      *   open a pull request.
      */
-    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = [], bumpOnlyOptions) {
+        var _a;
         const conventionalCommits = await this.postProcessCommits(commits);
         this.logger.info(`Considering: ${conventionalCommits.length} commits`);
-        if (conventionalCommits.length === 0) {
+        if (!bumpOnlyOptions && conventionalCommits.length === 0) {
             this.logger.info(`No commits for path: ${this.path}, skipping`);
             return undefined;
         }
-        const newVersion = await this.buildNewVersion(conventionalCommits, latestRelease);
+        const newVersion = (_a = bumpOnlyOptions === null || bumpOnlyOptions === void 0 ? void 0 : bumpOnlyOptions.newVersion) !== null && _a !== void 0 ? _a : (await this.buildNewVersion(conventionalCommits, latestRelease));
         const versionsMap = await this.updateVersionsMap(await this.buildVersionsMap(conventionalCommits), conventionalCommits, newVersion);
         const component = await this.getComponent();
         this.logger.debug('component:', component);
@@ -161,7 +162,7 @@ class BaseStrategy {
             ? branch_name_1.BranchName.ofComponentTargetBranch(branchComponent, this.targetBranch)
             : branch_name_1.BranchName.ofTargetBranch(this.targetBranch);
         const releaseNotesBody = await this.buildReleaseNotes(conventionalCommits, newVersion, newVersionTag, latestRelease, commits);
-        if (this.changelogEmpty(releaseNotesBody)) {
+        if (!bumpOnlyOptions && this.changelogEmpty(releaseNotesBody)) {
             this.logger.info(`No user facing commits found since ${latestRelease ? latestRelease.sha : 'beginning of time'} - skipping`);
             return undefined;
         }

package/build/src/strategies/java.d.ts

@@ -5,6 +5,7 @@ import { ConventionalCommit } from '../commit';
 import { Release } from '../release';
 import { ReleasePullRequest } from '../release-pull-request';
 import { VersioningStrategy } from '../versioning-strategy';
+import { BumpReleaseOptions } from '../strategy';
 export interface JavaBuildUpdatesOption extends BuildUpdatesOptions {
     isSnapshot?: boolean;
 }
@@ -18,7 +19,7 @@ export declare class Java extends BaseStrategy {
     protected readonly snapshotLabels: string[];
     readonly skipSnapshot: boolean;
     constructor(options: BaseStrategyOptions);
-    buildReleasePullRequest(commits: ConventionalCommit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    buildReleasePullRequest(commits: ConventionalCommit[], latestRelease?: Release, draft?: boolean, labels?: string[], _bumpOnlyOptions?: BumpReleaseOptions): Promise<ReleasePullRequest | undefined>;
     protected buildSnapshotPullRequest(latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest>;
     isPublishedVersion(version: Version): boolean;
     protected needsSnapshot(commits: ConventionalCommit[], latestRelease?: Release): Promise<boolean>;

package/build/src/strategies/java.js

@@ -58,7 +58,7 @@ class Java extends base_1.BaseStrategy {
         this.snapshotLabels = options.snapshotLabels || manifest_1.DEFAULT_SNAPSHOT_LABELS;
         this.skipSnapshot = (_c = options.skipSnapshot) !== null && _c !== void 0 ? _c : false;
     }
-    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = [], _bumpOnlyOptions) {
         if (await this.needsSnapshot(commits, latestRelease)) {
             this.logger.info('Repository needs a snapshot bump.');
             return await this.buildSnapshotPullRequest(latestRelease, draft, this.snapshotLabels);

package/build/src/strategies/node.js

@@ -27,6 +27,7 @@ class Node extends base_1.BaseStrategy {
         var _a;
         const updates = [];
         const version = options.newVersion;
+        const versionsMap = options.versionsMap;
         const packageName = (_a = (await this.getPackageName())) !== null && _a !== void 0 ? _a : '';
         const lockFiles = ['package-lock.json', 'npm-shrinkwrap.json'];
         lockFiles.forEach(lockFile => {
@@ -35,6 +36,7 @@ class Node extends base_1.BaseStrategy {
                 createIfMissing: false,
                 updater: new package_lock_json_1.PackageLockJson({
                     version,
+                    versionsMap,
                 }),
             });
         });

package/build/src/strategies/php-yoshi.d.ts

@@ -4,9 +4,10 @@ import { Commit } from '../commit';
 import { Release } from '../release';
 import { ReleasePullRequest } from '../release-pull-request';
 import { PullRequestBody } from '../util/pull-request-body';
+import { BumpReleaseOptions } from '../strategy';
 export declare class PHPYoshi extends BaseStrategy {
     constructor(options: BaseStrategyOptions);
-    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[], bumpOnlyOptions?: BumpReleaseOptions): Promise<ReleasePullRequest | undefined>;
     protected parsePullRequestBody(pullRequestBody: string): Promise<PullRequestBody | undefined>;
     protected buildUpdates(options: BuildUpdatesOptions): Promise<Update[]>;
 }

package/build/src/strategies/php-yoshi.js

@@ -48,10 +48,10 @@ class PHPYoshi extends base_1.BaseStrategy {
             changelogSections: CHANGELOG_SECTIONS,
         });
     }
-    async buildReleasePullRequest(commits, latestRelease, draft, labels = []) {
+    async buildReleasePullRequest(commits, latestRelease, draft, labels = [], bumpOnlyOptions) {
         var _a, _b, _c;
         const conventionalCommits = await this.postProcessCommits((0, commit_1.parseConventionalCommits)(commits, this.logger));
-        if (conventionalCommits.length === 0) {
+        if (!bumpOnlyOptions && conventionalCommits.length === 0) {
             this.logger.info(`No commits for path: ${this.path}, skipping`);
             return undefined;
         }

package/build/src/strategy.d.ts

@@ -8,6 +8,9 @@ import { Version } from './version';
 export interface BuildReleaseOptions {
     groupPullRequestTitlePattern?: string;
 }
+export interface BumpReleaseOptions {
+    newVersion: Version;
+}
 /**
  * A strategy is responsible for determining which files are
  * necessary to update in a release pull request.
@@ -23,11 +26,15 @@ export interface Strategy {
      *   component if available.
      * @param {boolean} draft Optional. Whether or not to create the pull
      *   request as a draft. Defaults to `false`.
+     * @param {BumpReleaseOptions} bumpOnlyOptions Optional. Options, that when
+     * present, indicate a release should be created even if there are no
+     * conventional commits. This is used when a release is required for
+     * a dependency update with a workspace plugin.
      * @returns {ReleasePullRequest | undefined} The release pull request to
      *   open for this path/component. Returns undefined if we should not
      *   open a pull request.
      */
-    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[]): Promise<ReleasePullRequest | undefined>;
+    buildReleasePullRequest(commits: Commit[], latestRelease?: Release, draft?: boolean, labels?: string[], bumpOnlyOptions?: BumpReleaseOptions): Promise<ReleasePullRequest | undefined>;
     /**
      * Given a merged pull request, build the candidate release.
      * @param {PullRequest} mergedPullRequest The merged release pull request.

package/build/src/updaters/node/package-json.d.ts

@@ -1,6 +1,16 @@
 import { Logger } from '../../util/logger';
+import { Version, VersionsMap } from '../../version';
 import { DefaultUpdater } from '../default';
-import { Version } from '../../version';
+export type PackageJsonDescriptor = {
+    name?: string;
+    resolved?: string;
+    link?: boolean;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+};
 /**
  * This updates a Node.js package.json file's main version.
  */
@@ -8,6 +18,7 @@ export declare class PackageJson extends DefaultUpdater {
     /**
      * Given initial file contents, return updated contents.
      * @param {string} content The initial content
+     * @param logger
      * @returns {string} The updated content
      */
     updateContent(content: string, logger?: Logger): string;
@@ -19,3 +30,11 @@ export declare class PackageJson extends DefaultUpdater {
  * @param {Version} newVersion The new version to update with
  */
 export declare function newVersionWithRange(oldVersion: string, newVersion: Version): string;
+/**
+ * Helper function to update dependency versions for all new versions specified
+ * in the updated versions map. Note that this mutates the existing input.
+ * @param {Record<string, string>} dependencies Entries in package.json dependencies
+ *   where the key is the dependency name and the value is the dependency range
+ * @param {VersionsMap} updatedVersions Map of new versions (without dependency range prefixes)
+ */
+export declare function updateDependencies(dependencies: Record<string, string>, updatedVersions: VersionsMap): void;

package/build/src/updaters/node/package-json.js

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newVersionWithRange = exports.PackageJson = void 0;
+exports.updateDependencies = exports.newVersionWithRange = exports.PackageJson = void 0;
 const json_stringify_1 = require("../../util/json-stringify");
 const logger_1 = require("../../util/logger");
 const default_1 = require("../default");
@@ -24,6 +24,7 @@ class PackageJson extends default_1.DefaultUpdater {
     /**
      * Given initial file contents, return updated contents.
      * @param {string} content The initial content
+     * @param logger
      * @returns {string} The updated content
      */
     updateContent(content, logger = logger_1.logger) {
@@ -88,9 +89,9 @@ function updateDependencies(dependencies, updatedVersions) {
         const newVersion = updatedVersions.get(depName);
         if (newVersion) {
             const oldVersion = dependencies[depName];
-            const newVersionString = newVersionWithRange(oldVersion, newVersion);
-            dependencies[depName] = newVersionString;
+            dependencies[depName] = newVersionWithRange(oldVersion, newVersion);
         }
     }
 }
+exports.updateDependencies = updateDependencies;
 //# sourceMappingURL=package-json.js.map

package/build/src/updaters/node/package-lock-json.d.ts

@@ -1,9 +1,14 @@
+import { Updater } from '../../update';
 import { Logger } from '../../util/logger';
-import { DefaultUpdater } from '../default';
+import { Version, VersionsMap } from '../../version';
+import { UpdateOptions } from '../default';
 /**
  * Updates a Node.js package-lock.json file's version and '' package
  * version (for a v2 lock file).
  */
-export declare class PackageLockJson extends DefaultUpdater {
+export declare class PackageLockJson implements Updater {
+    version?: Version;
+    versionsMap?: VersionsMap;
+    constructor(options: Partial<UpdateOptions>);
     updateContent(content: string, logger?: Logger): string;
 }

package/build/src/updaters/node/package-lock-json.js

@@ -16,21 +16,60 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageLockJson = void 0;
 const json_stringify_1 = require("../../util/json-stringify");
 const logger_1 = require("../../util/logger");
-const default_1 = require("../default");
+const package_json_1 = require("./package-json");
 /**
  * Updates a Node.js package-lock.json file's version and '' package
  * version (for a v2 lock file).
  */
-class PackageLockJson extends default_1.DefaultUpdater {
+class PackageLockJson {
+    constructor(options) {
+        this.version = options.version;
+        this.versionsMap = options.versionsMap;
+    }
     updateContent(content, logger = logger_1.logger) {
         const parsed = JSON.parse(content);
-        logger.info(`updating from ${parsed.version} to ${this.version}`);
-        parsed.version = this.version.toString();
+        if (this.version) {
+            logger.info(`updating from ${parsed.version} to ${this.version}`);
+            parsed.version = this.version.toString();
+        }
         if (parsed.lockfileVersion === 2 || parsed.lockfileVersion === 3) {
-            parsed.packages[''].version = this.version.toString();
+            if (this.version) {
+                parsed.packages[''].version = this.version.toString();
+            }
+            if (this.versionsMap) {
+                this.versionsMap.forEach((version, name) => {
+                    let pkg = parsed.packages['node_modules/' + name];
+                    if (!pkg) {
+                        return;
+                    }
+                    // @see https://docs.npmjs.com/cli/v10/configuring-npm/package-lock-json#packages
+                    if (pkg.link && pkg.resolved) {
+                        pkg = parsed.packages[pkg.resolved];
+                        if (!pkg) {
+                            return;
+                        }
+                    }
+                    pkg.version = version.toString();
+                    if (pkg.dependencies) {
+                        (0, package_json_1.updateDependencies)(pkg.dependencies, this.versionsMap);
+                    }
+                    if (pkg.devDependencies) {
+                        (0, package_json_1.updateDependencies)(pkg.devDependencies, this.versionsMap);
+                    }
+                    if (pkg.peerDependencies) {
+                        (0, package_json_1.updateDependencies)(pkg.peerDependencies, this.versionsMap);
+                    }
+                    if (pkg.optionalDependencies) {
+                        (0, package_json_1.updateDependencies)(pkg.optionalDependencies, this.versionsMap);
+                    }
+                });
+            }
         }
         if (this.versionsMap) {
             for (const [, obj] of Object.entries(parsed.packages)) {
+                if (!obj.name) {
+                    continue;
+                }
                 const ver = this.versionsMap.get(obj.name);
                 if (ver) {
                     obj.version = ver.toString();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "release-please",
-  "version": "16.5.1",
+  "version": "16.7.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
   "scripts": {
     "test": "cross-env ENVIRONMENT=test LC_ALL=en c8 mocha --node-option no-experimental-fetch --recursive --timeout=5000 build/test",
     "docs": "echo add docs tests",
-    "test:snap": "SNAPSHOT_UPDATE=1 LC_ALL=en npm test",
+    "test:snap": "cross-env SNAPSHOT_UPDATE=1 LC_ALL=en npm test",
     "clean": "gts clean",
     "prepare": "npm run compile",
     "lint": "gts check",