semantic-release-lerna 0.8.0 → 1.0.0

package/README.md

@@ -70,15 +70,13 @@ The plugin can be configured in the [**semantic-release** configuration file](ht
 }
 ```
 
-To use legacy auth set `NPM_USERNAME`, `NPM_PASSWORD` and `NPM_EMAIL`.
-
 ## Options
 
-| Option          | Description                                                                                                                                                                                             | Default   |
-| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
-| `npmVerifyAuth` | Set to `false` to disable verifying NPM registry credentials.                                                                                                                                           | `true`    |
+| Option          | Description                                                                                                                                                                                                           | Default   |
+| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
+| `npmVerifyAuth` | Set to `false` to disable verifying NPM registry credentials.                                                                                                                                                         | `true`    |
 | `latch`         | Latches package versions together. If the version bump is at least the given version all packages will be bumped regardless if the package has been touched or not. `"major", "minor", "patch", "prerelease", "none"` | `"minor"` |
-| `rootVersion`   | Allow to update version on root `package.json`.                                                                                                                                                         | `true`    |
+| `rootVersion`   | Allow to update version on root `package.json`.                                                                                                                                                                       | `true`    |
 
 ## Troubleshooting
 

package/index.js

@@ -1,16 +1,16 @@
-const AggregateError = require("aggregate-error");
-const tempy = require("tempy");
-const setLegacyToken = require("@semantic-release/npm/lib/set-legacy-token");
-const getPkg = require("@semantic-release/npm/lib/get-pkg");
-const verifyNpmConfig = require("@semantic-release/npm/lib/verify-config");
-const verifyNpmAuth = require("./lib/verify-auth");
-const verifyGit = require("./lib/verify-git");
-const prepareNpm = require("./lib/prepare");
-const publishNpm = require("./lib/publish");
-const generateNotes = require("./lib/generate-notes");
+import AggregateError from "aggregate-error";
+import { temporaryFile } from "tempy";
+import getPkg from "@semantic-release/npm/lib/get-pkg.js";
+import verifyNpmConfig from "@semantic-release/npm/lib/verify-config.js";
+import verifyNpmAuth from "./lib/verify-auth.js";
+import verifyGit from "./lib/verify-git.js";
+import prepareNpm from "./lib/prepare.js";
+import publishNpm from "./lib/publish.js";
+
+export { generateNotes } from "./lib/generate-notes.js";
 
 let verified;
-const npmrc = tempy.file({ name: ".npmrc" });
+const npmrc = temporaryFile({ name: ".npmrc" });
 
 const defaultConfig = {
 	npmVerifyAuth: true,
@@ -30,7 +30,7 @@ function defaultTo(value, defaultValue) {
 	return value === null || value === undefined ? defaultValue : value;
 }
 
-async function verifyConditions(pluginConfig, context) {
+export async function verifyConditions(pluginConfig, context) {
 	pluginConfig.npmVerifyAuth = defaultTo(pluginConfig.npmVerifyAuth, defaultConfig.npmVerifyAuth);
 	pluginConfig.npmPublish = defaultTo(pluginConfig.npmPublish, defaultConfig.npmPublish);
 	pluginConfig.tarballDir = defaultTo(pluginConfig.tarballDir, defaultConfig.tarballDir);
@@ -38,15 +38,13 @@ async function verifyConditions(pluginConfig, context) {
 
 	const errors = [...verifyNpmConfig(pluginConfig), ...(await verifyGit(context))];
 
-	setLegacyToken(context);
-
 	try {
 		if (pluginConfig.npmVerifyAuth) {
 			const pkg = await getPkg(pluginConfig, context);
 			await verifyNpmAuth(npmrc, pkg, context);
 		}
 	} catch (error) {
-		errors.push(...error);
+		errors.push(...error.errors);
 	}
 
 	if (errors.length > 0) {
@@ -56,13 +54,11 @@ async function verifyConditions(pluginConfig, context) {
 	verified = true;
 }
 
-async function prepare(pluginConfig, context) {
+export async function prepare(pluginConfig, context) {
 	pluginConfig.latch = defaultTo(pluginConfig.latch, defaultConfig.latch);
 
 	const errors = verified ? [] : verifyNpmConfig(pluginConfig);
 
-	setLegacyToken(context);
-
 	try {
 		if (pluginConfig.npmVerifyAuth) {
 			const pkg = await getPkg(pluginConfig, context);
@@ -79,12 +75,10 @@ async function prepare(pluginConfig, context) {
 	await prepareNpm(npmrc, pluginConfig, context);
 }
 
-async function publish(pluginConfig, context) {
+export async function publish(pluginConfig, context) {
 	let pkg;
 	const errors = verified ? [] : verifyNpmConfig(pluginConfig);
 
-	setLegacyToken(context);
-
 	try {
 		// Reload package.json in case a previous external step updated it
 		pkg = await getPkg(pluginConfig, context);
@@ -101,10 +95,3 @@ async function publish(pluginConfig, context) {
 
 	return publishNpm(npmrc, pluginConfig, pkg, context);
 }
-
-module.exports = {
-	verifyConditions,
-	prepare,
-	publish,
-	generateNotes,
-};

package/lib/definitions/errors.js

@@ -1,6 +1,6 @@
-module.exports = {
-	EDIRTYWC: ({ files }) => ({
+export function EDIRTYWC({ files }) {
+	return {
 		message: "Dirty working copy.",
 		details: `The git working copy must be clean before releasing:\n\n${files.join("\n")}\n`,
-	}),
-};
+	};
+}

package/lib/generate-notes.js

@@ -1,15 +1,17 @@
-const { format } = require("url");
-const getStream = require("get-stream");
-const intoStream = require("into-stream");
-const parser = require("conventional-commits-parser").sync;
-const writer = require("conventional-changelog-writer");
-const filter = require("conventional-commits-filter");
-const readPkgUp = require("read-pkg-up");
-const debug = require("debug")("semantic-release:release-notes-generator");
-const loadChangelogConfig = require("@semantic-release/release-notes-generator/lib/load-changelog-config");
-const HOSTS_CONFIG = require("@semantic-release/release-notes-generator/lib/hosts-config");
-const { makeDiffPredicate } = require("@lerna/collect-updates/lib/make-diff-predicate");
-const { Project } = require("@lerna/project");
+import { format } from "node:url";
+import getStream from "get-stream";
+import intoStream from "into-stream";
+import { sync as parser } from "conventional-commits-parser";
+import writer from "conventional-changelog-writer";
+import filter from "conventional-commits-filter";
+import { readPackageUp } from "read-pkg-up";
+import debugFactory from "debug";
+import loadChangelogConfig from "@semantic-release/release-notes-generator/lib/load-changelog-config.js";
+import HOSTS_CONFIG from "@semantic-release/release-notes-generator/lib/hosts-config.js";
+import { makeDiffPredicate } from "@lerna/collect-updates/lib/make-diff-predicate.js";
+import { Project } from "@lerna/project";
+
+const debug = debugFactory("semantic-release:release-notes-generator");
 
 /**
  * Generate the changelog for all the commits in `options.commits`.
@@ -27,8 +29,8 @@ const { Project } = require("@lerna/project");
  *
  * @returns {String} The changelog for all the commits in `context.commits`.
  */
-/* eslint-disable-next-line complexity, sonarjs/cognitive-complexity */
-async function generateNotes(pluginConfig, context) {
+/* eslint-disable-next-line complexity, sonarjs/cognitive-complexity -- technical debt */
+export async function generateNotes(pluginConfig, context) {
 	const { commits, lastRelease, nextRelease, options, cwd, logger } = context;
 	const { generateNotes = false } = pluginConfig;
 
@@ -58,7 +60,7 @@ async function generateNotes(pluginConfig, context) {
 	}
 
 	const [match, auth, host, path] =
-		/* eslint-disable-next-line security/detect-unsafe-regex */
+		/* eslint-disable-next-line security/detect-unsafe-regex -- technical debt  */
 		/^(?!.+:\/\/)(?:(?<auth>.*)@)?(?<host>.*?):(?<path>.*)$/.exec(repositoryUrl) || [];
 	const authString = auth ? `${auth}@` : "";
 	const url = new URL(match ? `ssh://${authString}${host}/${path}` : repositoryUrl);
@@ -66,7 +68,7 @@ async function generateNotes(pluginConfig, context) {
 	let { port, protocol } = url;
 	port = protocol.includes("ssh") ? "" : port;
 	protocol = protocol && /http[^s]/.test(protocol) ? "http" : "https";
-	/* eslint-disable-next-line security/detect-unsafe-regex */
+	/* eslint-disable-next-line security/detect-unsafe-regex -- technical debt  */
 	const [, owner, repository] = /^\/(?<owner>[^/]+)?\/?(?<repository>.+)?$/.exec(pathname);
 
 	const { issue, commit, referenceActions, issuePrefixes } =
@@ -107,7 +109,7 @@ async function generateNotes(pluginConfig, context) {
 		linkCompare: currentTag && previousTag,
 		issue,
 		commit,
-		packageData: ((await readPkgUp({ normalize: false, cwd })) || {}).packageJson,
+		packageData: ((await readPackageUp({ normalize: false, cwd })) || {}).packageJson,
 	};
 	const userConfig = {
 		host: hostConfig,
@@ -130,5 +132,3 @@ async function generateNotes(pluginConfig, context) {
 
 	return getStream(intoStream.object(parsedCommits).pipe(writer(changelogContext, writerOpts)));
 }
-
-module.exports = generateNotes;

package/lib/get-changed-packages.js

@@ -1,11 +1,11 @@
-const { format } = require("util");
-const { PackageGraph } = require("@lerna/package-graph");
-const { Project } = require("@lerna/project");
-const childProcess = require("@lerna/child-process");
-const { hasTags } = require("@lerna/collect-updates/lib/has-tags");
-const { collectPackages } = require("@lerna/collect-updates/lib/collect-packages");
-const { makeDiffPredicate } = require("@lerna/collect-updates/lib/make-diff-predicate");
-const shouldLatch = require("./should-latch");
+import { format } from "node:util";
+import { PackageGraph } from "@lerna/package-graph";
+import { Project } from "@lerna/project";
+import childProcess from "@lerna/child-process";
+import { hasTags } from "@lerna/collect-updates/lib/has-tags.js";
+import { collectPackages } from "@lerna/collect-updates/lib/collect-packages.js";
+import { makeDiffPredicate } from "@lerna/collect-updates/lib/make-diff-predicate.js";
+import { shouldLatch } from "./should-latch.js";
 
 function describeRefSync(execOptions) {
 	const args = [
@@ -37,7 +37,7 @@ function parse(stdout, options = {}) {
 		return { refCount, sha, isDirty: Boolean(isDirty) };
 	}
 
-	/* eslint-disable-next-line security/detect-unsafe-regex */
+	/* eslint-disable-next-line security/detect-unsafe-regex -- technical debt  */
 	const result = /^((?:.*@)?(.*))-(\d+)-g([\da-f]+)(-dirty)?$/.exec(stdout) || [];
 	const [, lastTagName, lastVersion, refCount, sha, isDirty] = result;
 
@@ -93,7 +93,7 @@ function collectUpdates(filteredPackages, packageGraph, execOptions, commandOpti
  * @param {any} context
  * @returns {Promise<any[]>}
  */
-async function getChangedPackages(latch, context) {
+export default async function getChangedPackages(latch, context) {
 	const { cwd, logger, version } = context;
 	const project = new Project(cwd);
 	const packages = await project.getPackages();
@@ -113,5 +113,3 @@ async function getChangedPackages(latch, context) {
 
 	return updates.map((node) => packages.find((pkg) => pkg.name === node.name));
 }
-
-module.exports = getChangedPackages;

package/lib/get-error.js

@@ -1,7 +1,8 @@
-const SemanticReleaseError = require("@semantic-release/error");
-const ERROR_DEFINITIONS = require("./definitions/errors");
+import SemanticReleaseError from "@semantic-release/error";
+import * as ERROR_DEFINITIONS from "./definitions/errors.js";
 
-module.exports = (code, ctx = {}) => {
+export default function (code, ctx = {}) {
+	/* eslint-disable-next-line import/namespace -- this is how upstream does it */
 	const { message, details } = ERROR_DEFINITIONS[code](ctx);
 	return new SemanticReleaseError(message, code, details);
-};
+}

package/lib/prepare.js

@@ -1,21 +1,20 @@
-const path = require("path");
-const fs = require("fs").promises;
-const { existsSync } = require("fs");
-const { format } = require("util");
-const execa = require("execa");
-const npmVersion = require("libnpmversion");
-const { Project } = require("@lerna/project");
-const { Package } = require("@lerna/package");
-const writeJsonFile = require("write-json-file");
-const semverParse = require("semver/functions/parse");
-const getChangedPackages = require("./get-changed-packages");
+import path from "node:path";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { format } from "node:util";
+import { execa } from "execa";
+import npmVersion from "libnpmversion";
+import { Project } from "@lerna/project";
+import { Package } from "@lerna/package";
+import { writeJsonFile } from "write-json-file";
+import semverParse from "semver/functions/parse.js";
+import getChangedPackages from "./get-changed-packages.js";
 
 /**
  * @param {string} path
  * @returns {any}
  **/
 async function readJson(path) {
-	/* eslint-disable-next-line security/detect-non-literal-fs-filename */
 	return JSON.parse(await fs.readFile(path));
 }
 
@@ -180,7 +179,7 @@ async function getCurrentVersion(pkg) {
  * @param {any} context
  * @returns {Promise<void>}
  */
-module.exports = async (npmrc, pluginConfig, context) => {
+export default async function (npmrc, pluginConfig, context) {
 	const {
 		cwd,
 		nextRelease: { version },
@@ -209,8 +208,6 @@ module.exports = async (npmrc, pluginConfig, context) => {
 
 	/* Bump version in all changed packages */
 	for (const pkg of changed) {
-		/* Want to perform version bumps in serial, disable eslint rule warning about it */
-		/* eslint-disable-next-line no-await-in-loop */
 		await updatePackage(npmrc, pkg, context, currentVersions);
 	}
 
@@ -223,4 +220,4 @@ module.exports = async (npmrc, pluginConfig, context) => {
 	} else {
 		logger.log("Don't write version to root package.json");
 	}
-};
+}

package/lib/publish.js

@@ -1,7 +1,8 @@
-const execa = require("execa");
-const getRegistry = require("@semantic-release/npm/lib/get-registry");
-const getChannel = require("@semantic-release/npm/lib/get-channel");
-const getReleaseInfo = require("@semantic-release/npm/lib/get-release-info");
+import { createRequire } from "node:module";
+import { execa } from "execa";
+import getRegistry from "@semantic-release/npm/lib/get-registry.js";
+import getChannel from "@semantic-release/npm/lib/get-channel.js";
+import getReleaseInfo from "@semantic-release/npm/lib/get-release-info.js";
 
 /**
  * @param {string} npmrc
@@ -9,7 +10,7 @@ const getReleaseInfo = require("@semantic-release/npm/lib/get-release-info");
  * @param {any} pkg
  * @param {any} context
  */
-module.exports = async (npmrc, config, pkg, context) => {
+export default async function (npmrc, config, pkg, context) {
 	const { npmPublish } = config;
 	const {
 		cwd,
@@ -26,14 +27,7 @@ module.exports = async (npmrc, config, pkg, context) => {
 
 		logger.log("Publishing version %s to npm registry", version);
 
-		let legacyAuth = [];
-		if (env.NPM_USERNAME && env.NPM_PASSWORD && env.NPM_EMAIL) {
-			legacyAuth = [
-				"--legacy-auth",
-				Buffer.from(`${env.NPM_USERNAME}:${env.NPM_PASSWORD}`, "utf8").toString("base64"),
-			];
-		}
-
+		const require = createRequire(import.meta.url);
 		const lerna = require.resolve("lerna/cli");
 		const result = execa(
 			"node",
@@ -46,7 +40,6 @@ module.exports = async (npmrc, config, pkg, context) => {
 				'--no-verify-access', // prepare step has already verify access and lerna doesn't properly pass authentication
 				'--dist-tag', distTag,
 				'--registry', registry,
-				...legacyAuth,
       ],
 			{
 				cwd,
@@ -68,4 +61,4 @@ module.exports = async (npmrc, config, pkg, context) => {
 	logger.log(`Skip publishing to npm registry as npmPublish false`);
 
 	return false;
-};
+}

package/lib/should-latch.js

@@ -1,7 +1,7 @@
-/* eslint-disable security/detect-unsafe-regex */
+/* eslint-disable security/detect-unsafe-regex -- technical debt  */
 const latchMajor = /^\d+\.0\.0$/;
 const latchMinor = /^\d+\.\d+\.0$/;
-const latchPatch = /^\d+\.\d\.\d+$/;
+const latchPatch = /^\d+\.\d+\.\d+$/;
 const latchPrerelease = /^\d+\.\d+\.\d+(-(.*\.)?\d+)?$/;
 
 /**
@@ -11,7 +11,7 @@ const latchPrerelease = /^\d+\.\d+\.\d+(-(.*\.)?\d+)?$/;
  * @param {"major" | "minor" | "patch" | "prerelease" | "none"} latch
  * @returns {boolean}
  */
-function shouldLatch(version, latch) {
+export function shouldLatch(version, latch) {
 	switch (latch) {
 		case "major":
 			return latchMajor.test(version);
@@ -25,5 +25,3 @@ function shouldLatch(version, latch) {
 			return false;
 	}
 }
-
-module.exports = shouldLatch;

package/lib/verify-auth.js

@@ -1,10 +1,10 @@
-const execa = require("execa");
-const AggregateError = require("aggregate-error");
-const getError = require("@semantic-release/npm/lib/get-error");
-const getRegistry = require("@semantic-release/npm/lib/get-registry");
-const setNpmrcAuth = require("@semantic-release/npm/lib/set-npmrc-auth");
+import { execa } from "execa";
+import AggregateError from "aggregate-error";
+import getError from "@semantic-release/npm/lib/get-error.js";
+import getRegistry from "@semantic-release/npm/lib/get-registry.js";
+import setNpmrcAuth from "@semantic-release/npm/lib/set-npmrc-auth.js";
 
-module.exports = async (npmrc, pkg, context) => {
+export default async function (npmrc, pkg, context) {
 	const { cwd, env, stdout, stderr } = context;
 	const registry = getRegistry(pkg, context);
 
@@ -21,4 +21,4 @@ module.exports = async (npmrc, pkg, context) => {
 	} catch {
 		throw new AggregateError([getError("EINVALIDNPMTOKEN", { registry })]);
 	}
-};
+}

package/lib/verify-git.js

@@ -1,5 +1,5 @@
-const execa = require("execa");
-const getError = require("./get-error");
+import { execa } from "execa";
+import getError from "./get-error.js";
 
 async function isDirty({ env }) {
 	const { stdout: wc } = await execa("git", ["status", "--porcelain"], { env });
@@ -12,7 +12,7 @@ const VALIDATORS = {
 	dirtyWc: isDirty,
 };
 
-async function verifyGit(context) {
+export default async function verifyGit(context) {
 	const result = await Promise.all(
 		Object.entries(VALIDATORS).map(async ([name, validator]) => {
 			const details = await validator(context);
@@ -23,5 +23,3 @@ async function verifyGit(context) {
 		.filter(([, details]) => details)
 		.map(([name, details]) => getError(`E${name.toUpperCase()}`, details));
 }
-
-module.exports = verifyGit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantic-release-lerna",
-  "version": "0.8.0",
+  "version": "1.0.0",
   "description": "semantic-release plugin to publish lerna monorepo packages to npm",
   "keywords": [
     "npm",
@@ -25,6 +25,7 @@
     "Stephan Bönnemann <stephan@boennemann.me> (http://boennemann.me)",
     "Gregor Martynus (https://twitter.com/gr2m)"
   ],
+  "type": "module",
   "main": "index.js",
   "files": [
     "lib",
@@ -33,8 +34,8 @@
   ],
   "scripts": {
     "codecov": "codecov -f coverage/coverage-final.json",
-    "eslint": "eslint .",
-    "eslint:fix": "eslint --fix .",
+    "eslint": "eslint --cache .",
+    "eslint:fix": "eslint --cache --fix .",
     "prettier:check": "prettier --check .",
     "prettier:write": "prettier --write .",
     "semantic-release": "semantic-release",
@@ -43,7 +44,8 @@
   },
   "prettier": "@html-validate/prettier-config",
   "jest": {
-    "testTimeout": 10000
+    "testTimeout": 30000,
+    "transformIgnorePatterns": []
   },
   "dependencies": {
     "@lerna/child-process": "^6.0.0",
@@ -52,44 +54,47 @@
     "@lerna/package-graph": "^6.0.0",
     "@lerna/project": "^6.0.0",
     "@semantic-release/error": "^3.0.0",
-    "@semantic-release/release-notes-generator": "^10.0.0",
-    "aggregate-error": "^3.1.0",
+    "@semantic-release/release-notes-generator": "^11.0.0",
+    "aggregate-error": "^4.0.0",
     "conventional-changelog-writer": "^5.0.0",
     "conventional-commits-filter": "^2.0.0",
     "conventional-commits-parser": "^3.2.0",
     "debug": "^4.3.0",
-    "execa": "^5.0.0",
+    "execa": "^7.0.0",
     "get-stream": "^6.0.0",
-    "into-stream": "^6.0.0",
+    "into-stream": "^7.0.0",
     "libnpmversion": "^4.0.0",
-    "read-pkg-up": "^7.0.0",
+    "read-pkg-up": "^9.0.0",
     "semver": "^7.0.0",
-    "tempy": "^1.0.0",
-    "write-json-file": "^4.0.0"
+    "tempy": "^3.0.0",
+    "write-json-file": "^5.0.0"
   },
   "devDependencies": {
-    "@html-validate/eslint-config": "5.5.22",
-    "@html-validate/eslint-config-jest": "5.5.18",
-    "@html-validate/prettier-config": "2.3.4",
-    "@semantic-release/npm": "9.0.2",
-    "@types/jest": "29.4.0",
+    "@babel/core": "7.21.8",
+    "@babel/preset-env": "7.21.5",
+    "@html-validate/eslint-config": "5.9.4",
+    "@html-validate/eslint-config-jest": "5.9.0",
+    "@html-validate/prettier-config": "2.3.10",
+    "@semantic-release/npm": "10.0.3",
+    "@types/jest": "29.5.1",
+    "babel-plugin-transform-import-meta": "2.2.0",
     "codecov": "3.8.3",
-    "fs-extra": "11.1.0",
-    "got": "11.8.6",
-    "jest": "29.4.2",
-    "lerna": "6.4.1",
-    "prettier": "2.8.4",
-    "semantic-release": "20.1.0",
+    "fs-extra": "11.1.1",
+    "jest": "29.5.0",
+    "lerna": "6.6.2",
+    "npm-pkg-lint": "1.14.1",
+    "prettier": "2.8.8",
+    "semantic-release": "21.0.2",
     "stream-buffers": "3.0.2",
-    "verdaccio": "5.19.1"
+    "verdaccio": "5.24.1"
   },
   "peerDependencies": {
-    "@semantic-release/npm": ">= 7",
+    "@semantic-release/npm": ">= 10",
     "lerna": "^3.2 || ^4 || ^5 || ^6",
-    "semantic-release": ">=15.0.0 <21.0.0"
+    "semantic-release": "^20.1 || 21"
   },
   "engines": {
-    "node": ">= 14"
+    "node": ">= 18"
   },
   "publishConfig": {
     "access": "public"

package/lib/prepare.test.js

@@ -1,477 +0,0 @@
-/* eslint-env jest */
-const path = require("path");
-const { outputJson, readJson } = require("fs-extra");
-const tempy = require("tempy");
-const execa = require("execa");
-const { WritableStreamBuffer } = require("stream-buffers");
-const prepare = require("./prepare");
-
-let context;
-let mockChangedPackages;
-
-jest.mock("../lib/get-changed-packages", () => {
-	function getChangedPackagesMock() {
-		return mockChangedPackages;
-	}
-
-	return getChangedPackagesMock;
-});
-
-async function createProject(cwd, version, pkgData) {
-	const lernaPath = path.resolve(cwd, "lerna.json");
-	const manifestLocation = path.resolve(cwd, "package.json");
-	await outputJson(lernaPath, { version, packages: ["packages/*"] });
-	await outputJson(manifestLocation, { name: "root-pkg", version, ...pkgData });
-	return {
-		lernaPath,
-		manifestLocation,
-	};
-}
-
-/* eslint-disable-next-line max-params */
-async function createPackage(cwd, name, version, options, pkgData) {
-	const { changed = false } = options;
-	const pkgRoot = `packages/${name}`;
-	const location = path.resolve(cwd, pkgRoot);
-	const manifestLocation = path.resolve(cwd, pkgRoot, "package.json");
-	const pkg = {
-		name,
-		location,
-		manifestLocation,
-		shrinkwrapPath: path.resolve(cwd, pkgRoot, "npm-shrinkwrap.json"),
-		lockfilePath: path.resolve(cwd, pkgRoot, "package-lock.json"),
-	};
-	await outputJson(manifestLocation, { name, version, ...pkgData });
-	if (changed) {
-		mockChangedPackages.push(pkg);
-	}
-
-	return pkg;
-}
-
-beforeEach(() => {
-	const log = jest.fn();
-	context = {
-		log,
-		logger: { log },
-		stdout: new WritableStreamBuffer(),
-		stderr: new WritableStreamBuffer(),
-	};
-	mockChangedPackages = [];
-});
-
-it("Update lerna.json and root package.json when no package has changed", async () => {
-	expect.assertions(4);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	const project = await createProject(cwd, "0.0.0");
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify lerna.json has been updated
-	expect(await readJson(project.lernaPath)).toEqual(
-		expect.objectContaining({
-			version: "1.0.0",
-		})
-	);
-
-	// Verify root package.json has been updated
-	expect(await readJson(project.manifestLocation)).toEqual(
-		expect.objectContaining({
-			version: "1.0.0",
-		})
-	);
-
-	// Verify the logger has been called with the version updated
-	expect(context.log).toHaveBeenCalledWith(
-		"No packages changed, applying version bump on root package only"
-	);
-	expect(context.log).toHaveBeenCalledWith("Write version %s to lerna.json in %s", "1.0.0", cwd);
-});
-
-it("Update lerna.json and root package.json when one or more package has changed", async () => {
-	expect.assertions(5);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	const project = await createProject(cwd, "0.0.0");
-	const pkg = await createPackage(cwd, "foo", "0.0.0", {
-		changed: true,
-	});
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify lerna.json has been updated
-	expect(await readJson(project.lernaPath)).toEqual(
-		expect.objectContaining({
-			version: "1.0.0",
-		})
-	);
-
-	// Verify package.json has been updated
-	expect(await readJson(project.manifestLocation)).toEqual(
-		expect.objectContaining({
-			version: "1.0.0",
-		})
-	);
-
-	// Verify the logger has been called with the version updated
-	expect(context.log).toHaveBeenCalledWith("1 package need version bump: [ 'foo' ]");
-	expect(context.log).toHaveBeenCalledWith(
-		"Write version %s to package.json in %s",
-		"1.0.0",
-		pkg.location
-	);
-	expect(context.log).toHaveBeenCalledWith("Write version %s to lerna.json in %s", "1.0.0", cwd);
-});
-
-it("Update only lerna.json when one or more package has changed when option `rootVersion` is `false`", async () => {
-	expect.assertions(4);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	const project = await createProject(cwd, "0.0.0");
-
-	await createPackage(cwd, "foo", "0.0.0", {
-		changed: true,
-	});
-
-	await prepare(
-		npmrc,
-		{
-			rootVersion: false,
-		},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify lerna.json has been updated
-	expect(await readJson(project.lernaPath)).toEqual(
-		expect.objectContaining({
-			version: "1.0.0",
-		})
-	);
-
-	// Verify the logger has been called with the version updated
-	expect(context.log).toHaveBeenCalledWith("1 package need version bump: [ 'foo' ]");
-	expect(context.log).toHaveBeenCalledWith("Write version %s to lerna.json in %s", "1.0.0", cwd);
-	expect(context.log).toHaveBeenCalledWith("Don't write version to root package.json");
-});
-
-it("Update package.json in changed packages", async () => {
-	expect.assertions(2);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.0.0");
-	const foo = await createPackage(cwd, "foo", "0.0.0", {
-		changed: true,
-	});
-	const bar = await createPackage(cwd, "bar", "0.0.0", {
-		changed: false,
-	});
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify foo/package.json has been updated
-	expect(await readJson(foo.manifestLocation)).toEqual({
-		name: "foo",
-		version: "1.0.0",
-	});
-
-	// Verify bar/package.json has not been updated
-	expect(await readJson(bar.manifestLocation)).toEqual({
-		name: "bar",
-		version: "0.0.0",
-	});
-});
-
-it("Update npm-shrinkwrap.json if present", async () => {
-	expect.assertions(2);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.0.0");
-	const pkg = await createPackage(cwd, "foo", "0.0.0", {
-		changed: true,
-	});
-	// Create a npm-shrinkwrap.json file
-	await execa("npm", ["shrinkwrap"], { cwd: pkg.location });
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify foo/package.json has been updated
-	expect(await readJson(pkg.manifestLocation)).toEqual({
-		name: "foo",
-		version: "1.0.0",
-	});
-
-	// Verify foo/npm-shrinkwrap.json has been updated
-	expect(await readJson(pkg.shrinkwrapPath)).toEqual(
-		expect.objectContaining({
-			lockfileVersion: expect.anything(),
-			name: "foo",
-			version: "1.0.0",
-		})
-	);
-});
-
-it("Update package-lock.json if present", async () => {
-	expect.assertions(2);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.0.0");
-	const pkg = await createPackage(cwd, "foo", "0.0.0", {
-		changed: true,
-	});
-	// Create a package-lock.json file
-	await execa("npm", ["install"], { cwd: pkg.location });
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify foo/package.json has been updated
-	expect(await readJson(pkg.manifestLocation)).toEqual({
-		name: "foo",
-		version: "1.0.0",
-	});
-
-	// Verify foo/package-lock.json has been updated
-	expect(await readJson(pkg.lockfilePath)).toEqual(
-		expect.objectContaining({
-			lockfileVersion: expect.anything(),
-			name: "foo",
-			version: "1.0.0",
-		})
-	);
-});
-
-it("Update package.json dependency when using exact version", async () => {
-	expect.assertions(1);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.0.0");
-	const foo = await createPackage(
-		cwd,
-		"foo",
-		"0.0.0",
-		{
-			changed: true,
-		},
-		{
-			dependencies: {
-				a: "0.0.0",
-			},
-			devDependencies: {
-				b: "0.0.0",
-			},
-			peerDependencies: {
-				c: "0.0.0",
-			},
-		}
-	);
-	await createPackage(cwd, "a", "0.0.0", { changed: true });
-	await createPackage(cwd, "b", "0.0.0", { changed: true });
-	await createPackage(cwd, "c", "0.0.0", { changed: true });
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "0.0.1" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify dependency has been updated
-	expect(await readJson(foo.manifestLocation)).toEqual({
-		name: "foo",
-		version: "0.0.1",
-		dependencies: {
-			a: "0.0.1",
-		},
-		devDependencies: {
-			b: "0.0.1",
-		},
-		peerDependencies: {
-			c: "0.0.1",
-		},
-	});
-});
-
-it("Update package.json dependency when using hat", async () => {
-	expect.assertions(1);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.1.2");
-	const foo = await createPackage(
-		cwd,
-		"foo",
-		"0.1.2",
-		{
-			changed: true,
-		},
-		{
-			dependencies: {
-				a: "^0.1.2",
-				b: "^0.1",
-				c: "^0",
-			},
-		}
-	);
-
-	await createPackage(cwd, "a", "0.1.2", { changed: true });
-	await createPackage(cwd, "b", "0.1.2", { changed: true });
-	await createPackage(cwd, "c", "0.1.2", { changed: true });
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "1.0.0" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify dependency has been updated
-	expect(await readJson(foo.manifestLocation)).toEqual({
-		name: "foo",
-		version: "1.0.0",
-		dependencies: {
-			a: "^1.0.0",
-			b: "^1.0",
-			c: "^1",
-		},
-	});
-});
-
-it("Should not update other dependencies", async () => {
-	expect.assertions(1);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.0.0");
-	const foo = await createPackage(
-		cwd,
-		"foo",
-		"0.0.0",
-		{
-			changed: true,
-		},
-		{
-			dependencies: {
-				a: "0.0.0",
-			},
-		}
-	);
-
-	await prepare(
-		npmrc,
-		{},
-		{
-			cwd,
-			env: {},
-			stdout: context.stdout,
-			stderr: context.stderr,
-			nextRelease: { version: "0.0.1" },
-			logger: context.logger,
-		}
-	);
-
-	// Verify dependency has been updated
-	expect(await readJson(foo.manifestLocation)).toEqual({
-		name: "foo",
-		version: "0.0.1",
-		dependencies: {
-			a: "0.0.0",
-		},
-	});
-});
-
-it("Handle dependencies from root package", async () => {
-	expect.assertions(1);
-	const cwd = tempy.directory();
-	const npmrc = tempy.file({ name: ".npmrc" });
-	await createProject(cwd, "0.0.1", {
-		devDependencies: {
-			"external-dependency": "1.2.3",
-		},
-	});
-	expect(async () => {
-		await prepare(
-			npmrc,
-			{},
-			{
-				cwd,
-				env: {},
-				stdout: context.stdout,
-				stderr: context.stderr,
-				nextRelease: { version: "0.0.2" },
-				logger: context.logger,
-			}
-		);
-	}).not.toThrow();
-});

package/lib/should-latch.test.js

@@ -1,71 +0,0 @@
-/* eslint-env jest */
-
-const semver = require("semver");
-const shouldLatch = require("./should-latch");
-
-const version = "1.0.0";
-
-describe("latch none", () => {
-	it.each`
-		bump            | result   | version    | next
-		${"major"}      | ${false} | ${version} | ${semver.inc(version, "major")}
-		${"minor"}      | ${false} | ${version} | ${semver.inc(version, "minor")}
-		${"patch"}      | ${false} | ${version} | ${semver.inc(version, "patch")}
-		${"prerelease"} | ${false} | ${version} | ${semver.inc(version, "prerelease")}
-	`("should return $result when version bump is $bump ($version -> $next)", ({ result, next }) => {
-		expect.assertions(1);
-		expect(shouldLatch(next, "none")).toBe(result);
-	});
-});
-
-describe("latch major", () => {
-	it.each`
-		bump            | result   | version    | next
-		${"major"}      | ${true}  | ${version} | ${semver.inc(version, "major")}
-		${"minor"}      | ${false} | ${version} | ${semver.inc(version, "minor")}
-		${"patch"}      | ${false} | ${version} | ${semver.inc(version, "patch")}
-		${"prerelease"} | ${false} | ${version} | ${semver.inc(version, "prerelease")}
-	`("should return $result when version bump is $bump ($version -> $next)", ({ result, next }) => {
-		expect.assertions(1);
-		expect(shouldLatch(next, "major")).toBe(result);
-	});
-});
-
-describe("latch minor", () => {
-	it.each`
-		bump            | result   | version    | next
-		${"major"}      | ${true}  | ${version} | ${semver.inc(version, "major")}
-		${"minor"}      | ${true}  | ${version} | ${semver.inc(version, "minor")}
-		${"patch"}      | ${false} | ${version} | ${semver.inc(version, "patch")}
-		${"prerelease"} | ${false} | ${version} | ${semver.inc(version, "prerelease")}
-	`("should return $result when version bump is $bump ($version -> $next)", ({ result, next }) => {
-		expect.assertions(1);
-		expect(shouldLatch(next, "minor")).toBe(result);
-	});
-});
-
-describe("latch patch", () => {
-	it.each`
-		bump            | result   | version    | next
-		${"major"}      | ${true}  | ${version} | ${semver.inc(version, "major")}
-		${"minor"}      | ${true}  | ${version} | ${semver.inc(version, "minor")}
-		${"patch"}      | ${true}  | ${version} | ${semver.inc(version, "patch")}
-		${"prerelease"} | ${false} | ${version} | ${semver.inc(version, "prerelease")}
-	`("should return $result when version bump is $bump ($version -> $next)", ({ result, next }) => {
-		expect.assertions(1);
-		expect(shouldLatch(next, "patch")).toBe(result);
-	});
-});
-
-describe("latch prerelease", () => {
-	it.each`
-		bump            | result  | version    | next
-		${"major"}      | ${true} | ${version} | ${semver.inc(version, "major")}
-		${"minor"}      | ${true} | ${version} | ${semver.inc(version, "minor")}
-		${"patch"}      | ${true} | ${version} | ${semver.inc(version, "patch")}
-		${"prerelease"} | ${true} | ${version} | ${semver.inc(version, "prerelease")}
-	`("should return $result when version bump is $bump ($version -> $next)", ({ result, next }) => {
-		expect.assertions(1);
-		expect(shouldLatch(next, "prerelease")).toBe(result);
-	});
-});

package/lib/verify-git.test.js

@@ -1,49 +0,0 @@
-/* eslint-env jest */
-
-jest.mock("execa");
-
-const execa = require("execa");
-const verifyGit = require("./verify-git");
-
-it("should return error if working copy is dirty", async () => {
-	expect.assertions(2);
-	execa.mockImplementation(() => ({ stdout: " M file.js\n" }));
-	const errors = await verifyGit({});
-	expect(errors).toHaveLength(1);
-	expect(errors[0]).toMatchObject({
-		code: "EDIRTYWC",
-		details: `The git working copy must be clean before releasing:
-
- M file.js
-`,
-	});
-});
-
-it("should return error when working copy has mixed dirty and untracked", async () => {
-	expect.assertions(2);
-	execa.mockImplementation(() => ({ stdout: " M file.js\n?? file.c" }));
-	const errors = await verifyGit({});
-	expect(errors).toHaveLength(1);
-	expect(errors[0]).toMatchObject({
-		code: "EDIRTYWC",
-		details: `The git working copy must be clean before releasing:
-
- M file.js
-?? file.c
-`,
-	});
-});
-
-it("should ignore untracked files", async () => {
-	expect.assertions(1);
-	execa.mockImplementation(() => ({ stdout: "?? file.js\n" }));
-	const errors = await verifyGit({});
-	expect(errors).toHaveLength(0);
-});
-
-it("should not return error if working copy is clean", async () => {
-	expect.assertions(1);
-	execa.mockImplementation(() => ({ stdout: "" }));
-	const errors = await verifyGit({});
-	expect(errors).toHaveLength(0);
-});