From 59d0412e618090a71f243c0ab9d66f202641e5ea Mon Sep 17 00:00:00 2001 From: Guillaume Roux Date: Thu, 12 Nov 2026 14:08:50 +0100 Subject: [PATCH] feat(create-release-branch): load Changesets and list their candidates Add the first part of the Changesets mode. loadChangesets reads the workspace packages, the Changesets configuration, and the release plan of all pending Changesets. It stops with a setup error when the configuration is missing or not valid, when its changelog setting is not @metamask/changesets-changelog, or when the project is in Changesets pre mode. listChangesetsCandidates lists the packages that the plan bumps, as packages with changes or with only a dependency bump. Remove the legacy-entries candidate kind. No mode lists such packages. --- packages/create-release-branch/package.json | 4 + .../src/core/candidates.ts | 12 +- .../src/core/release-steps.test.ts | 7 +- .../src/core/release-steps.ts | 4 +- .../src/modes/changesets/candidates.test.ts | 180 ++++++++++++++ .../src/modes/changesets/candidates.ts | 78 +++++++ .../src/modes/changesets/load.test.ts | 220 ++++++++++++++++++ .../src/modes/changesets/load.ts | 161 +++++++++++++ .../tests/unit/helpers.ts | 24 ++ yarn.lock | 18 ++ 10 files changed, 691 insertions(+), 17 deletions(-) create mode 100644 packages/create-release-branch/src/modes/changesets/candidates.test.ts create mode 100644 packages/create-release-branch/src/modes/changesets/candidates.ts create mode 100644 packages/create-release-branch/src/modes/changesets/load.test.ts create mode 100644 packages/create-release-branch/src/modes/changesets/load.ts diff --git a/packages/create-release-branch/package.json b/packages/create-release-branch/package.json index 7dfd2adb..e6ac9729 100644 --- a/packages/create-release-branch/package.json +++ b/packages/create-release-branch/package.json @@ -44,7 +44,11 @@ "test:watch": "vitest --watch" }, "dependencies": { + "@changesets/config": "^4.0.1", + "@changesets/get-release-plan": "^5.0.2", + "@changesets/types": "^7.0.0", "@clack/prompts": "^1.8.1", + "@manypkg/get-packages": "^3.1.0", "@metamask/action-utils": "^2.0.0", "@metamask/auto-changelog": "^7.1.0", "@metamask/utils": "^11.12.0", diff --git a/packages/create-release-branch/src/core/candidates.ts b/packages/create-release-branch/src/core/candidates.ts index c4909cc8..1c3f3e63 100644 --- a/packages/create-release-branch/src/core/candidates.ts +++ b/packages/create-release-branch/src/core/candidates.ts @@ -1,6 +1,6 @@ /** - * Why a package is offered for release: it has changes, it depends on a - * package that is being released, or it has entries in its changelog. + * Why a package is offered for release: it has changes, or it depends on a + * package that is being released. */ export type CandidateKind = /** @@ -11,13 +11,7 @@ export type CandidateKind = /** * The package is released only because one of its dependencies is released. */ - | 'dependency' - /** - * Changesets mode only: the package has no changesets, but its changelog has - * hand-written entries in its Unreleased section (during the migration to - * Changesets). - */ - | 'legacy-entries'; + | 'dependency'; /** * A package that the maintainer can choose to include in the release. diff --git a/packages/create-release-branch/src/core/release-steps.test.ts b/packages/create-release-branch/src/core/release-steps.test.ts index af403e03..446e0436 100644 --- a/packages/create-release-branch/src/core/release-steps.test.ts +++ b/packages/create-release-branch/src/core/release-steps.test.ts @@ -387,26 +387,23 @@ describe('release-steps', () => { }); }); - it('passes only changes and legacy-entries candidates as packages with changes', async () => { + it('passes only changes candidates as packages with changes', async () => { const project = buildMockProject({ workspacePackages: { a: buildMockPackage('a', '1.0.0', { validatedManifest: { dependencies: { changed: '1.0.0', dependent: '1.0.0' }, - peerDependencies: { legacy: '1.0.0' }, }, }), changed: buildMockPackage('changed', '1.0.0'), dependent: buildMockPackage('dependent', '1.0.0', { hasChangesSinceLatestRelease: true, }), - legacy: buildMockPackage('legacy', '1.0.0'), }, }); const candidates: Candidate[] = [ { name: 'changed', currentVersion: '1.0.0', kind: 'changes' }, { name: 'dependent', currentVersion: '1.0.0', kind: 'dependency' }, - { name: 'legacy', currentVersion: '1.0.0', kind: 'legacy-entries' }, ]; const plan = vi.fn(); const mode = buildMockMode({ @@ -424,7 +421,7 @@ describe('release-steps', () => { a: { missingDirectDependentNames: [], missingPeerDependentNames: [], - missingDependencies: ['changed', 'legacy'], + missingDependencies: ['changed'], }, }); expect(plan).not.toHaveBeenCalled(); diff --git a/packages/create-release-branch/src/core/release-steps.ts b/packages/create-release-branch/src/core/release-steps.ts index 14ef9dd5..185acd2b 100644 --- a/packages/create-release-branch/src/core/release-steps.ts +++ b/packages/create-release-branch/src/core/release-steps.ts @@ -132,9 +132,7 @@ export async function checkChoices({ }): Promise> { const candidates = await mode.listCandidates(choices); const packagesWithChanges = new Set( - candidates - .filter(({ kind }) => kind === 'changes' || kind === 'legacy-entries') - .map(({ name }) => name), + candidates.filter(({ kind }) => kind === 'changes').map(({ name }) => name), ); const { errors, dependencyFindings } = checkReleaseChoices(project, choices, { diff --git a/packages/create-release-branch/src/modes/changesets/candidates.test.ts b/packages/create-release-branch/src/modes/changesets/candidates.test.ts new file mode 100644 index 00000000..7b599996 --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/candidates.test.ts @@ -0,0 +1,180 @@ +import { describe, expect, it } from 'vitest'; + +import { + buildMockChangesetsState, + buildMockPackage, + buildMockProject, +} from '../../../tests/unit/helpers.js'; +import { compareNames, listChangesetsCandidates } from './candidates.js'; + +describe('candidates', () => { + describe('listChangesetsCandidates', () => { + it('lists the packages with changes, then with a dependency bump, each sorted by name', () => { + const project = buildMockProject({ + workspacePackages: { + '@scope/b': buildMockPackage('@scope/b', '1.0.0'), + '@scope/a': buildMockPackage('@scope/a', '1.0.0'), + '@scope/c': buildMockPackage('@scope/c', '1.0.0'), + '@scope/z': buildMockPackage('@scope/z', '1.0.0'), + }, + }); + const state = buildMockChangesetsState({ + fullPlan: { + changesets: [ + { + id: 'brave-cats-sing', + summary: '', + releases: [{ name: '@scope/b', type: 'major' }], + }, + { + id: 'calm-dogs-run', + summary: '', + releases: [ + { name: '@scope/a', type: 'patch' }, + { name: '@scope/b', type: 'patch' }, + ], + }, + { + id: 'eager-owls-fly', + summary: '', + releases: [{ name: '@scope/a', type: 'patch' }], + }, + ], + releases: [ + { + name: '@scope/z', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: [], + }, + { + name: '@scope/b', + type: 'major', + oldVersion: '1.0.0', + newVersion: '2.0.0', + changesets: ['brave-cats-sing', 'calm-dogs-run'], + }, + { + name: '@scope/c', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: [], + }, + { + name: '@scope/a', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: ['calm-dogs-run', 'eager-owls-fly'], + }, + ], + preState: undefined, + }, + }); + + expect(listChangesetsCandidates(project, state)).toStrictEqual([ + { + name: '@scope/a', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'changes', + changeCount: 2, + }, + { + name: '@scope/b', + currentVersion: '1.0.0', + plannedVersion: '2.0.0', + kind: 'changes', + changeCount: 2, + }, + { + name: '@scope/c', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'dependency', + }, + { + name: '@scope/z', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'dependency', + }, + ]); + }); + + it('does not list or count a release of type "none"', () => { + const project = buildMockProject({ + workspacePackages: { + '@scope/a': buildMockPackage('@scope/a', '1.0.0'), + '@scope/b': buildMockPackage('@scope/b', '1.0.0'), + }, + }); + const state = buildMockChangesetsState({ + fullPlan: { + changesets: [ + { + id: 'brave-cats-sing', + summary: '', + releases: [ + { name: '@scope/a', type: 'none' }, + { name: '@scope/b', type: 'patch' }, + ], + }, + ], + releases: [ + { + name: '@scope/a', + type: 'none', + oldVersion: '1.0.0', + newVersion: '1.0.0', + changesets: ['brave-cats-sing'], + }, + { + name: '@scope/b', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: ['brave-cats-sing'], + }, + ], + preState: undefined, + }, + }); + + expect(listChangesetsCandidates(project, state)).toStrictEqual([ + { + name: '@scope/b', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'changes', + changeCount: 1, + }, + ]); + }); + + it('lists no package when there are no pending Changesets', () => { + const project = buildMockProject({ + workspacePackages: { + '@scope/a': buildMockPackage('@scope/a', '1.0.0'), + }, + }); + + expect( + listChangesetsCandidates(project, buildMockChangesetsState()), + ).toStrictEqual([]); + }); + }); + + describe('compareNames', () => { + it('orders names by code unit', () => { + expect(['b', 'B', 'a', 'a'].sort(compareNames)).toStrictEqual([ + 'B', + 'a', + 'a', + 'b', + ]); + }); + }); +}); diff --git a/packages/create-release-branch/src/modes/changesets/candidates.ts b/packages/create-release-branch/src/modes/changesets/candidates.ts new file mode 100644 index 00000000..1453fb1a --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/candidates.ts @@ -0,0 +1,78 @@ +import type { ComprehensiveRelease } from '@changesets/types'; + +import type { Candidate, CandidateKind } from '../../core/candidates.js'; +import type { Project } from '../../project/project.js'; +import type { ChangesetsState } from './load.js'; + +/** + * A release that bumps the version of its package. + */ +export type BumpingRelease = Exclude; + +const KIND_ORDER: CandidateKind[] = ['changes', 'dependency']; + +/** + * Compares two strings by code unit, whatever the locale. + * + * @param left - The first string. + * @param right - The second string. + * @returns A negative number, zero, or a positive number. + */ +export function compareNames(left: string, right: string): number { + return Number(left > right) - Number(left < right); +} + +/** + * Determines whether a release bumps the version of its package. + * + * @param release - The release. + * @returns Whether the release type is not `none`. + */ +export function isBumpingRelease( + release: ComprehensiveRelease, +): release is BumpingRelease { + return release.type !== 'none'; +} + +/** + * Lists the packages that the full release plan bumps. + * + * @param project - The project. + * @param state - The Changesets state. + * @returns The candidates, grouped by kind and sorted by name. + */ +export function listChangesetsCandidates( + project: Project, + state: ChangesetsState, +): Candidate[] { + return state.fullPlan.releases + .filter(isBumpingRelease) + .map(({ name, newVersion }): Candidate => { + const currentVersion = + project.workspacePackages[name].validatedManifest.version.version; + const changeCount = state.fullPlan.changesets.filter(({ releases }) => + releases.some( + (release) => release.name === name && release.type !== 'none', + ), + ).length; + return changeCount > 0 + ? { + name, + currentVersion, + plannedVersion: newVersion, + kind: 'changes', + changeCount, + } + : { + name, + currentVersion, + plannedVersion: newVersion, + kind: 'dependency', + }; + }) + .sort( + (left, right) => + KIND_ORDER.indexOf(left.kind) - KIND_ORDER.indexOf(right.kind) || + compareNames(left.name, right.name), + ); +} diff --git a/packages/create-release-branch/src/modes/changesets/load.test.ts b/packages/create-release-branch/src/modes/changesets/load.test.ts new file mode 100644 index 00000000..ad7c7a4b --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/load.test.ts @@ -0,0 +1,220 @@ +import { defaultConfig, readConfig } from '@changesets/config'; +import { getReleasePlan } from '@changesets/get-release-plan'; +import type { Config } from '@changesets/types'; +import { getPackages } from '@manypkg/get-packages'; +import { describe, expect, it, vi } from 'vitest'; + +import { buildMockChangesetsState } from '../../../tests/unit/helpers.js'; +import { + CHANGELOG_MODULE, + ChangesetsSetupError, + loadChangesets, +} from './load.js'; +import type { ChangesetsState } from './load.js'; + +vi.mock(import('@changesets/config'), async (importActual) => ({ + ...(await importActual()), + readConfig: vi.fn(), +})); +vi.mock('@changesets/get-release-plan'); +vi.mock('@manypkg/get-packages'); + +const CONFIG_PATH = '/path/to/project/.changeset/config.json'; + +const CONFIG: Config = { + ...defaultConfig, + changelog: [CHANGELOG_MODULE, { repository: 'example-org/example-repo' }], +}; + +const format = { + name: (text: string): string => `<${text}>`, + dim: (text: string): string => `(${text})`, +}; + +/** + * Mocks what Changesets reads from the project. + * + * @param overrides - The parts of the state to change. + * @returns The mocked state. + */ +function mockChangesetsState( + overrides: Partial = {}, +): ChangesetsState { + const state = buildMockChangesetsState({ config: CONFIG, ...overrides }); + vi.mocked(getPackages).mockResolvedValue( + state.packages as Awaited>, + ); + vi.mocked(readConfig).mockResolvedValue({ + config: state.config, + warnings: [], + errors: undefined, + }); + vi.mocked(getReleasePlan).mockResolvedValue(state.fullPlan); + return state; +} + +describe('load', () => { + describe('loadChangesets', () => { + it('reads the packages, the configuration, and the release plan of all pending Changesets', async () => { + const state = mockChangesetsState({ + fullPlan: { + changesets: [ + { + id: 'brave-cats-sing', + summary: 'Add a feature', + releases: [{ name: '@scope/a', type: 'minor' }], + }, + ], + releases: [ + { + name: '@scope/a', + type: 'minor', + oldVersion: '1.0.0', + newVersion: '1.1.0', + changesets: ['brave-cats-sing'], + }, + ], + preState: undefined, + }, + }); + + expect(await loadChangesets('/path/to/project')).toStrictEqual(state); + expect(readConfig).toHaveBeenCalledWith( + '/path/to/project', + state.packages, + ); + expect(getReleasePlan).toHaveBeenCalledWith( + '/path/to/project', + undefined, + state.config, + ); + }); + + it('accepts a project that is exiting Changesets pre mode', async () => { + mockChangesetsState({ + fullPlan: { + changesets: [], + releases: [], + preState: { mode: 'exit', tag: 'beta' }, + }, + }); + + const { fullPlan } = await loadChangesets('/path/to/project'); + + expect(fullPlan.preState?.mode).toBe('exit'); + }); + + it('throws a setup error if the project has no Changesets configuration', async () => { + mockChangesetsState(); + const cause = Object.assign(new Error('Not found'), { code: 'ENOENT' }); + vi.mocked(readConfig).mockRejectedValue(cause); + + const promise = loadChangesets('/path/to/project'); + + await expect(promise).rejects.toThrow( + new ChangesetsSetupError({ + problem: 'Changesets mode needs a Changesets configuration.', + details: [ + 'Set up Changesets in the project, or release it in legacy mode.', + ], + filePath: CONFIG_PATH, + }), + ); + await expect(promise).rejects.toHaveProperty('cause', cause); + }); + + it('throws other errors from reading the configuration as they are', async () => { + mockChangesetsState(); + const error = new SyntaxError('Unexpected end of JSON input'); + vi.mocked(readConfig).mockRejectedValue(error); + + await expect(loadChangesets('/path/to/project')).rejects.toBe(error); + }); + + it('throws a setup error that lists the problems of a configuration that is not valid', async () => { + mockChangesetsState(); + vi.mocked(readConfig).mockResolvedValue({ + config: undefined, + warnings: [], + errors: ['Problem 1', 'Problem 2'], + }); + + await expect(loadChangesets('/path/to/project')).rejects.toThrow( + new ChangesetsSetupError({ + problem: 'The Changesets configuration is not valid:', + details: ['Problem 1', 'Problem 2'], + filePath: CONFIG_PATH, + }), + ); + }); + + it.each([ + { description: 'no changelog module', changelog: false as const }, + { + description: 'another changelog module', + changelog: ['@changesets/cli/changelog', null] as const, + }, + ])( + 'throws a setup error if the configuration has $description', + async ({ changelog }) => { + mockChangesetsState({ config: { ...CONFIG, changelog } }); + + await expect(loadChangesets('/path/to/project')).rejects.toThrow( + new ChangesetsSetupError({ + problem: + 'Changesets mode needs the @metamask/changesets-changelog changelog module.', + details: [ + 'Set "changelog" to ["@metamask/changesets-changelog", { "repository": "/" }] in the Changesets configuration.', + ], + filePath: CONFIG_PATH, + }), + ); + }, + ); + + it('throws a setup error if the project is in Changesets pre mode', async () => { + mockChangesetsState({ + fullPlan: { + changesets: [], + releases: [], + preState: { mode: 'pre', tag: 'beta' }, + }, + }); + + await expect(loadChangesets('/path/to/project')).rejects.toThrow( + new ChangesetsSetupError({ + problem: 'Changesets pre mode is not supported.', + details: [ + 'Exit pre mode with "changeset pre exit", then run this tool again.', + ], + filePath: '/path/to/project/.changeset/pre.json', + }), + ); + }); + }); + + describe('ChangesetsSetupError', () => { + it('describes the problem, the details, then the file path', () => { + const error = new ChangesetsSetupError({ + problem: 'Some problem.', + details: ['Some detail.'], + filePath: '/some/file', + }); + + expect(error.describe(format)).toStrictEqual({ + title: 'Some problem.', + lines: ['Some detail.', '(/some/file)'], + }); + expect(error.message).toBe('Some problem.\nSome detail.\n/some/file'); + }); + + it('has no file path line if there is no file path', () => { + const error = new ChangesetsSetupError({ + problem: 'Some problem.', + details: ['Some detail.'], + }); + + expect(error.message).toBe('Some problem.\nSome detail.'); + }); + }); +}); diff --git a/packages/create-release-branch/src/modes/changesets/load.ts b/packages/create-release-branch/src/modes/changesets/load.ts new file mode 100644 index 00000000..3de49ded --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/load.ts @@ -0,0 +1,161 @@ +import { readConfig } from '@changesets/config'; +import { getReleasePlan } from '@changesets/get-release-plan'; +import type { Config, Packages, ReleasePlan } from '@changesets/types'; +import { getPackages } from '@manypkg/get-packages'; +import path from 'path'; + +import type { CliOutput } from '../../core/cli-output.js'; +import type { ErrorDescription } from '../../core/user-facing-error.js'; +import { UserFacingError } from '../../core/user-facing-error.js'; +import { isErrorWithCode } from '../../utils/misc-utils.js'; + +/** + * The changelog module that Changesets mode requires. + */ +export const CHANGELOG_MODULE = '@metamask/changesets-changelog'; + +/** + * The workspace packages, the Changesets configuration, and the release plan + * of all pending Changesets. + */ +export type ChangesetsState = { + packages: Packages; + config: Config; + fullPlan: ReleasePlan; +}; + +/** + * A problem that stops Changesets mode before it writes anything. + */ +export class ChangesetsSetupError extends UserFacingError { + problem: string; + + details: string[]; + + filePath: string | undefined; + + /** + * Creates the error. + * + * @param args - The arguments. + * @param args.problem - What is wrong. + * @param args.details - How to fix it. + * @param args.filePath - The file that has the problem. + * @param options - The options. + * @param options.cause - The error that caused the problem. + */ + constructor( + { + problem, + details, + filePath, + }: { problem: string; details: string[]; filePath?: string }, + options?: { cause: unknown }, + ) { + super(undefined, options); + this.problem = problem; + this.details = details; + this.filePath = filePath; + const plain = (text: string): string => text; + const { title, lines } = this.describe({ name: plain, dim: plain }); + this.message = [title, ...lines].join('\n'); + } + + describe(format: CliOutput['format']): ErrorDescription { + return { + title: this.problem, + lines: + this.filePath === undefined + ? this.details + : [...this.details, format.dim(this.filePath)], + }; + } +} + +/** + * Reads the Changesets configuration, which must use {@link CHANGELOG_MODULE}. + * + * @param projectDirectoryPath - The path to the project root. + * @param packages - The workspace packages. + * @returns The configuration. + */ +async function readChangesetsConfig( + projectDirectoryPath: string, + packages: Packages, +): Promise { + const configPath = path.join( + projectDirectoryPath, + '.changeset', + 'config.json', + ); + + let result: Awaited>; + try { + result = await readConfig(projectDirectoryPath, packages); + } catch (error) { + if (isErrorWithCode(error) && error.code === 'ENOENT') { + throw new ChangesetsSetupError( + { + problem: 'Changesets mode needs a Changesets configuration.', + details: [ + 'Set up Changesets in the project, or release it in legacy mode.', + ], + filePath: configPath, + }, + { cause: error }, + ); + } + throw error; + } + + if (result.errors !== undefined) { + throw new ChangesetsSetupError({ + problem: 'The Changesets configuration is not valid:', + details: result.errors, + filePath: configPath, + }); + } + + const { changelog } = result.config; + if (changelog === false || changelog[0] !== CHANGELOG_MODULE) { + throw new ChangesetsSetupError({ + problem: `Changesets mode needs the ${CHANGELOG_MODULE} changelog module.`, + details: [ + `Set "changelog" to ["${CHANGELOG_MODULE}", { "repository": "/" }] in the Changesets configuration.`, + ], + filePath: configPath, + }); + } + + return result.config; +} + +/** + * Reads the Changesets state of the project. Pre mode is not supported. + * + * @param projectDirectoryPath - The path to the project root. + * @returns The Changesets state. + */ +export async function loadChangesets( + projectDirectoryPath: string, +): Promise { + const packages = await getPackages(projectDirectoryPath); + const config = await readChangesetsConfig(projectDirectoryPath, packages); + const fullPlan = await getReleasePlan( + projectDirectoryPath, + undefined, + config, + ); + + if (fullPlan.preState?.mode === 'pre') { + throw new ChangesetsSetupError({ + problem: 'Changesets pre mode is not supported.', + details: [ + 'Exit pre mode with "changeset pre exit", then run this tool again.', + ], + filePath: path.join(projectDirectoryPath, '.changeset', 'pre.json'), + }); + } + + return { packages, config, fullPlan }; +} diff --git a/packages/create-release-branch/tests/unit/helpers.ts b/packages/create-release-branch/tests/unit/helpers.ts index 20e6f023..71ece440 100644 --- a/packages/create-release-branch/tests/unit/helpers.ts +++ b/packages/create-release-branch/tests/unit/helpers.ts @@ -1,3 +1,4 @@ +import { defaultConfig } from '@changesets/config'; import { isPlainObject } from '@metamask/utils'; import fs from 'fs'; import path from 'path'; @@ -8,6 +9,7 @@ import { vi } from 'vitest'; import { createCliOutput } from '../../src/core/cli-output.js'; import type { CliOutput } from '../../src/core/cli-output.js'; import type { Mode, ModePrepareStep } from '../../src/core/mode.js'; +import type { ChangesetsState } from '../../src/modes/changesets/load.js'; import { PackageManifestDependenciesFieldNames, PackageManifestFieldNames, @@ -141,6 +143,28 @@ export function buildMockPackage( }; } +/** + * Builds a Changesets state for use in tests. All properties have default + * values, so you can specify only the properties you care about. + * + * @param overrides - The properties that will go into the object. + * @returns The mock ChangesetsState. + */ +export function buildMockChangesetsState( + overrides: Partial = {}, +): ChangesetsState { + return { + packages: { + rootDir: '/path/to/project', + packages: [], + tool: { type: 'yarn' }, + }, + config: defaultConfig, + fullPlan: { changesets: [], releases: [], preState: undefined }, + ...overrides, + }; +} + /** * Builds a manifest object for use in tests. All properties have default * values, so you can specify only the properties you care about. diff --git a/yarn.lock b/yarn.lock index 0c5a6997..0cbf36ff 100644 --- a/yarn.lock +++ b/yarn.lock @@ -358,6 +358,20 @@ __metadata: languageName: node linkType: hard +"@changesets/get-release-plan@npm:^5.0.2": + version: 5.0.2 + resolution: "@changesets/get-release-plan@npm:5.0.2" + dependencies: + "@changesets/assemble-release-plan": "npm:^7.0.0" + "@changesets/config": "npm:^4.0.1" + "@changesets/pre": "npm:^3.0.0" + "@changesets/read": "npm:^1.0.1" + "@changesets/types": "npm:^7.0.0" + "@manypkg/get-packages": "npm:^3.1.0" + checksum: 10/26261a7e6889755ed63613b1728dda781480c2344af8c77f66497832ac6c12dc95f11ecf364875ab5fa5f72129b3f4c46102b721d5dce2101e4d293dcbc867f5 + languageName: node + linkType: hard + "@changesets/git@npm:^4.0.1": version: 4.0.1 resolution: "@changesets/git@npm:4.0.1" @@ -1069,7 +1083,11 @@ __metadata: version: 0.0.0-use.local resolution: "@metamask/create-release-branch@workspace:packages/create-release-branch" dependencies: + "@changesets/config": "npm:^4.0.1" + "@changesets/get-release-plan": "npm:^5.0.2" + "@changesets/types": "npm:^7.0.0" "@clack/prompts": "npm:^1.8.1" + "@manypkg/get-packages": "npm:^3.1.0" "@metamask/action-utils": "npm:^2.0.0" "@metamask/auto-changelog": "npm:^7.1.0" "@metamask/utils": "npm:^11.12.0"