@jsenv/package-publish 1.10.0 → 1.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/package-publish",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "description": "Publish package to one or many registry.",
   "license": "MIT",
   "author": {
@@ -11,7 +11,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/jsenv/workflow",
-    "directory": "packages/jsenv-package-publish"
+    "directory": "packages/package-publish"
   },
   "engines": {
     "node": ">=16.13.0"
@@ -34,9 +34,9 @@
     "test": "node --experimental-json-modules ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/fetch": "1.1.3",
-    "@jsenv/filesystem": "4.1.0",
-    "@jsenv/log": "3.0.0",
-    "semver": "7.3.7"
+    "@jsenv/fetch": "1.1.32",
+    "@jsenv/filesystem": "4.2.3",
+    "@jsenv/log": "3.3.4",
+    "semver": "7.5.0"
   }
 }

package/src/internal/fetchLatestInRegistry.js

@@ -2,14 +2,14 @@
 // https://github.com/npm/registry-issue-archive/issues/34
 // https://stackoverflow.com/questions/53212849/querying-information-about-specific-version-of-scoped-npm-package
 
-import { fetchUrl } from "@jsenv/fetch"
+import { fetchUrl } from "@jsenv/fetch";
 
 export const fetchLatestInRegistry = async ({
   registryUrl,
   packageName,
   token,
 }) => {
-  const requestUrl = `${registryUrl}/${packageName}`
+  const requestUrl = `${registryUrl}/${packageName}`;
   const response = await fetchUrl(requestUrl, {
     method: "GET",
     headers: {
@@ -22,10 +22,10 @@ export const fetchLatestInRegistry = async ({
           }
         : {}),
     },
-  })
-  const responseStatus = response.status
+  });
+  const responseStatus = response.status;
   if (responseStatus === 404) {
-    return null
+    return null;
   }
   if (responseStatus !== 200) {
     throw new Error(
@@ -34,11 +34,11 @@ export const fetchLatestInRegistry = async ({
         responseStatus,
         responseText: await response.text(),
       }),
-    )
+    );
   }
-  const packageObject = await response.json()
-  return packageObject.versions[packageObject["dist-tags"].latest]
-}
+  const packageObject = await response.json();
+  return packageObject.versions[packageObject["dist-tags"].latest];
+};
 
 const writeUnexpectedResponseStatus = ({
   requestUrl,
@@ -50,4 +50,4 @@ ${requestUrl}
 --- response status ---
 ${responseStatus}
 --- response text ---
-${responseText}`
+${responseText}`;

package/src/internal/needsPublish.js

@@ -1,62 +1,63 @@
-import { createRequire } from "node:module"
+import { createRequire } from "node:module";
 
-const require = createRequire(import.meta.url)
+const require = createRequire(import.meta.url);
 // https://github.com/npm/node-semver#readme
 const {
   gt: versionGreaterThan,
   prerelease: versionToPrerelease,
-} = require("semver")
+} = require("semver");
 
-export const PUBLISH_BECAUSE_NEVER_PUBLISHED = "never-published"
-export const PUBLISH_BECAUSE_LATEST_LOWER = "latest-lower"
-export const PUBLISH_BECAUSE_TAG_DIFFERS = "tag-differs"
+export const PUBLISH_BECAUSE_NEVER_PUBLISHED = "never-published";
+export const PUBLISH_BECAUSE_LATEST_LOWER = "latest-lower";
+export const PUBLISH_BECAUSE_TAG_DIFFERS = "tag-differs";
 
-export const NOTHING_BECAUSE_LATEST_HIGHER = "latest-higher"
-export const NOTHING_BECAUSE_ALREADY_PUBLISHED = "already-published"
+export const NOTHING_BECAUSE_LATEST_HIGHER = "latest-higher";
+export const NOTHING_BECAUSE_ALREADY_PUBLISHED = "already-published";
 
 export const needsPublish = ({ registryLatestVersion, packageVersion }) => {
   if (registryLatestVersion === null) {
-    return PUBLISH_BECAUSE_NEVER_PUBLISHED
+    return PUBLISH_BECAUSE_NEVER_PUBLISHED;
   }
   if (registryLatestVersion === packageVersion) {
-    return NOTHING_BECAUSE_ALREADY_PUBLISHED
+    return NOTHING_BECAUSE_ALREADY_PUBLISHED;
   }
   if (versionGreaterThan(registryLatestVersion, packageVersion)) {
-    return NOTHING_BECAUSE_LATEST_HIGHER
+    return NOTHING_BECAUSE_LATEST_HIGHER;
   }
   const registryLatestVersionPrerelease = versionToPrerelease(
     registryLatestVersion,
-  )
-  const packageVersionPrerelease = versionToPrerelease(packageVersion)
+  );
+  const packageVersionPrerelease = versionToPrerelease(packageVersion);
   if (
     registryLatestVersionPrerelease === null &&
     packageVersionPrerelease === null
   ) {
-    return PUBLISH_BECAUSE_LATEST_LOWER
+    return PUBLISH_BECAUSE_LATEST_LOWER;
   }
   if (
     registryLatestVersionPrerelease === null &&
     packageVersionPrerelease !== null
   ) {
-    return PUBLISH_BECAUSE_LATEST_LOWER
+    return PUBLISH_BECAUSE_LATEST_LOWER;
   }
   if (
     registryLatestVersionPrerelease !== null &&
     packageVersionPrerelease === null
   ) {
-    return PUBLISH_BECAUSE_LATEST_LOWER
+    return PUBLISH_BECAUSE_LATEST_LOWER;
   }
   const [registryReleaseTag, registryPrereleaseVersion] =
-    registryLatestVersionPrerelease
-  const [packageReleaseTag, packagePreReleaseVersion] = packageVersionPrerelease
+    registryLatestVersionPrerelease;
+  const [packageReleaseTag, packagePreReleaseVersion] =
+    packageVersionPrerelease;
   if (registryReleaseTag !== packageReleaseTag) {
-    return PUBLISH_BECAUSE_TAG_DIFFERS
+    return PUBLISH_BECAUSE_TAG_DIFFERS;
   }
   if (registryPrereleaseVersion === packagePreReleaseVersion) {
-    return NOTHING_BECAUSE_ALREADY_PUBLISHED
+    return NOTHING_BECAUSE_ALREADY_PUBLISHED;
   }
   if (registryPrereleaseVersion > packagePreReleaseVersion) {
-    return NOTHING_BECAUSE_LATEST_HIGHER
+    return NOTHING_BECAUSE_LATEST_HIGHER;
   }
-  return PUBLISH_BECAUSE_LATEST_LOWER
-}
+  return PUBLISH_BECAUSE_LATEST_LOWER;
+};

package/src/internal/publish.js

@@ -1,10 +1,10 @@
-import { fileURLToPath } from "node:url"
-import { readFileSync, writeFileSync } from "node:fs"
-import { exec } from "node:child_process"
-import { createTaskLog } from "@jsenv/log"
-import { removeEntry } from "@jsenv/filesystem"
+import { fileURLToPath } from "node:url";
+import { readFileSync, writeFileSync } from "node:fs";
+import { exec } from "node:child_process";
+import { createTaskLog } from "@jsenv/log";
+import { removeEntry } from "@jsenv/filesystem";
 
-import { setNpmConfig } from "./setNpmConfig.js"
+import { setNpmConfig } from "./setNpmConfig.js";
 
 export const publish = async ({
   logger,
@@ -14,47 +14,47 @@ export const publish = async ({
   registryUrl,
   token,
 }) => {
-  const publishTask = createTaskLog(`publish ${packageSlug} on ${registryUrl}`)
+  const publishTask = createTaskLog(`publish ${packageSlug} on ${registryUrl}`);
   try {
     // process.env.NODE_AUTH_TOKEN
-    const previousValue = process.env.NODE_AUTH_TOKEN
+    const previousValue = process.env.NODE_AUTH_TOKEN;
     const restoreProcessEnv = () => {
-      process.env.NODE_AUTH_TOKEN = previousValue
-    }
-    process.env.NODE_AUTH_TOKEN = token
+      process.env.NODE_AUTH_TOKEN = previousValue;
+    };
+    process.env.NODE_AUTH_TOKEN = token;
     // updating package.json to publish on the correct registry
-    let restorePackageFile = () => {}
-    const rootPackageFileUrl = new URL("./package.json", rootDirectoryUrl)
-    const rootPackageFileContent = readFileSync(rootPackageFileUrl)
-    const packageObject = JSON.parse(String(rootPackageFileContent))
-    const { publishConfig } = packageObject
+    let restorePackageFile = () => {};
+    const rootPackageFileUrl = new URL("./package.json", rootDirectoryUrl);
+    const rootPackageFileContent = readFileSync(rootPackageFileUrl);
+    const packageObject = JSON.parse(String(rootPackageFileContent));
+    const { publishConfig } = packageObject;
     const registerUrlFromPackage = publishConfig
       ? publishConfig.registry || "https://registry.npmjs.org"
-      : "https://registry.npmjs.org"
+      : "https://registry.npmjs.org";
     if (registryUrl !== registerUrlFromPackage) {
       restorePackageFile = () =>
-        writeFileSync(rootPackageFileUrl, rootPackageFileContent)
-      packageObject.publishConfig = packageObject.publishConfig || {}
-      packageObject.publishConfig.registry = registryUrl
+        writeFileSync(rootPackageFileUrl, rootPackageFileContent);
+      packageObject.publishConfig = packageObject.publishConfig || {};
+      packageObject.publishConfig.registry = registryUrl;
       writeFileSync(
         rootPackageFileUrl,
         JSON.stringify(packageObject, null, "  "),
-      )
+      );
     }
     // updating .npmrc to add the token
-    const npmConfigFileUrl = new URL("./.npmrc", rootDirectoryUrl)
-    let restoreNpmConfigFile
-    let npmConfigFileContent
+    const npmConfigFileUrl = new URL("./.npmrc", rootDirectoryUrl);
+    let restoreNpmConfigFile;
+    let npmConfigFileContent;
     try {
-      npmConfigFileContent = String(readFileSync(npmConfigFileUrl))
+      npmConfigFileContent = String(readFileSync(npmConfigFileUrl));
       restoreNpmConfigFile = () =>
-        writeFileSync(npmConfigFileUrl, npmConfigFileContent)
+        writeFileSync(npmConfigFileUrl, npmConfigFileContent);
     } catch (e) {
       if (e.code === "ENOENT") {
-        restoreNpmConfigFile = () => removeEntry(npmConfigFileUrl)
-        npmConfigFileContent = ""
+        restoreNpmConfigFile = () => removeEntry(npmConfigFileUrl);
+        npmConfigFileContent = "";
       } else {
-        throw e
+        throw e;
       }
     }
     writeFileSync(
@@ -63,7 +63,7 @@ export const publish = async ({
         [computeRegistryTokenKey(registryUrl)]: token,
         [computeRegistryKey(packageObject.name)]: registryUrl,
       }),
-    )
+    );
     try {
       const reason = await new Promise((resolve, reject) => {
         const command = exec(
@@ -89,14 +89,14 @@ export const publish = async ({
                 resolve({
                   success: true,
                   reason: "already-published",
-                })
+                });
               } else if (
                 error.message.includes("Cannot publish over existing version")
               ) {
                 resolve({
                   success: true,
                   reason: "already-published",
-                })
+                });
               } else if (
                 error.message.includes(
                   "You cannot publish over the previously published versions",
@@ -105,7 +105,7 @@ export const publish = async ({
                 resolve({
                   success: true,
                   reason: "already-published",
-                })
+                });
               }
               // github publish conflict
               else if (
@@ -116,71 +116,71 @@ export const publish = async ({
                 resolve({
                   success: true,
                   reason: "already-published",
-                })
+                });
               } else {
-                reject(error)
+                reject(error);
               }
             } else {
               resolve({
                 success: true,
                 reason: "published",
-              })
+              });
             }
           },
-        )
+        );
         if (logNpmPublishOutput) {
           command.stdout.on("data", (data) => {
-            logger.debug(data)
-          })
+            logger.debug(data);
+          });
           command.stderr.on("data", (data) => {
             // debug because this output is part of
             // the error message generated by a failing npm publish
-            logger.debug(data)
-          })
+            logger.debug(data);
+          });
         }
-      })
+      });
       if (reason === "already-published") {
-        publishTask.setRightText(`(already published)`)
+        publishTask.setRightText(`(already published)`);
       }
-      publishTask.done()
+      publishTask.done();
       return {
         success: true,
         reason,
-      }
+      };
     } finally {
-      restoreProcessEnv()
-      restorePackageFile()
-      restoreNpmConfigFile()
+      restoreProcessEnv();
+      restorePackageFile();
+      restoreNpmConfigFile();
     }
   } catch (e) {
-    publishTask.fail()
-    console.error(e.stack)
+    publishTask.fail();
+    console.error(e.stack);
     return {
       success: false,
       reason: e,
-    }
+    };
   }
-}
+};
 
 const computeRegistryTokenKey = (registryUrl) => {
   if (registryUrl.startsWith("http://")) {
-    return `${registryUrl.slice("http:".length)}/:_authToken`
+    return `${registryUrl.slice("http:".length)}/:_authToken`;
   }
   if (registryUrl.startsWith("https://")) {
-    return `${registryUrl.slice("https:".length)}/:_authToken`
+    return `${registryUrl.slice("https:".length)}/:_authToken`;
   }
   if (registryUrl.startsWith("//")) {
-    return `${registryUrl}/:_authToken`
+    return `${registryUrl}/:_authToken`;
   }
   throw new Error(
     `registryUrl must start with http or https, got ${registryUrl}`,
-  )
-}
+  );
+};
 
 const computeRegistryKey = (packageName) => {
   if (packageName[0] === "@") {
-    const packageScope = packageName.slice(0, packageName.indexOf("/"))
-    return `${packageScope}:registry`
+    const packageScope = packageName.slice(0, packageName.indexOf("/"));
+    return `${packageScope}:registry`;
   }
-  return `registry`
-}
+  return `registry`;
+};

package/src/internal/readProjectPackage.js

@@ -1,22 +1,22 @@
-import { fileURLToPath } from "node:url"
-import { readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 
 export const readProjectPackage = ({ rootDirectoryUrl }) => {
-  const packageFileUrlObject = new URL("./package.json", rootDirectoryUrl)
-  let packageInProject
+  const packageFileUrlObject = new URL("./package.json", rootDirectoryUrl);
+  let packageInProject;
   try {
-    const packageString = String(readFileSync(packageFileUrlObject))
+    const packageString = String(readFileSync(packageFileUrlObject));
     try {
-      packageInProject = JSON.parse(packageString)
+      packageInProject = JSON.parse(packageString);
     } catch (e) {
       if (e.name === "SyntaxError") {
         throw new Error(`syntax error while parsing project package.json
 --- syntax error stack ---
 ${e.stack}
 --- package.json path ---
-${fileURLToPath(packageFileUrlObject)}`)
+${fileURLToPath(packageFileUrlObject)}`);
       }
-      throw e
+      throw e;
     }
   } catch (e) {
     if (e.code === "ENOENT") {
@@ -24,9 +24,9 @@ ${fileURLToPath(packageFileUrlObject)}`)
         `cannot find project package.json
 --- package.json path ---
 ${fileURLToPath(packageFileUrlObject)}`,
-      )
+      );
     }
-    throw e
+    throw e;
   }
-  return packageInProject
-}
+  return packageInProject;
+};

package/src/internal/setNpmConfig.js

@@ -1,25 +1,25 @@
 export const setNpmConfig = (configString, configObject) => {
   return Object.keys(configObject).reduce((previous, key) => {
-    return setOrUpdateNpmConfig(previous, key, configObject[key])
-  }, configString)
-}
+    return setOrUpdateNpmConfig(previous, key, configObject[key]);
+  }, configString);
+};
 
 const setOrUpdateNpmConfig = (config, key, value) => {
-  const assignmentIndex = config.indexOf(`${key}=`)
+  const assignmentIndex = config.indexOf(`${key}=`);
   if (assignmentIndex === -1) {
     if (config === "") {
-      return `${key}=${value}`
+      return `${key}=${value}`;
     }
     return `${config}
-${key}=${value}`
+${key}=${value}`;
   }
 
-  const beforeAssignment = config.slice(0, assignmentIndex)
-  const nextLineIndex = config.indexOf("\n", assignmentIndex)
+  const beforeAssignment = config.slice(0, assignmentIndex);
+  const nextLineIndex = config.indexOf("\n", assignmentIndex);
   if (nextLineIndex === -1) {
-    return `${beforeAssignment}${key}=${value}`
+    return `${beforeAssignment}${key}=${value}`;
   }
 
-  const afterAssignment = config.slice(nextLineIndex)
-  return `${beforeAssignment}${key}=${value}${afterAssignment}`
-}
+  const afterAssignment = config.slice(nextLineIndex);
+  return `${beforeAssignment}${key}=${value}${afterAssignment}`;
+};

package/src/main.js

@@ -5,4 +5,4 @@
  *   discover codebase progressively
  */
 
-export { publishPackage } from "./publishPackage.js"
+export { publishPackage } from "./publishPackage.js";

package/src/publishPackage.js

@@ -1,9 +1,9 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/log"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { createLogger } from "@jsenv/log";
 
-import { fetchLatestInRegistry } from "./internal/fetchLatestInRegistry.js"
-import { publish } from "./internal/publish.js"
-import { readProjectPackage } from "./internal/readProjectPackage.js"
+import { fetchLatestInRegistry } from "./internal/fetchLatestInRegistry.js";
+import { publish } from "./internal/publish.js";
+import { readProjectPackage } from "./internal/readProjectPackage.js";
 import {
   needsPublish,
   PUBLISH_BECAUSE_NEVER_PUBLISHED,
@@ -11,7 +11,7 @@ import {
   PUBLISH_BECAUSE_TAG_DIFFERS,
   NOTHING_BECAUSE_LATEST_HIGHER,
   NOTHING_BECAUSE_ALREADY_PUBLISHED,
-} from "../src/internal/needsPublish.js"
+} from "./internal/needsPublish.js";
 
 export const publishPackage = async ({
   logLevel,
@@ -20,24 +20,24 @@ export const publishPackage = async ({
   logNpmPublishOutput = true,
   updateProcessExitCode = true,
 } = {}) => {
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
   logger.debug(
     `publishPackage(${JSON.stringify(
       { rootDirectoryUrl, logLevel, registriesConfig },
       null,
       "  ",
     )})`,
-  )
-  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
-  assertRegistriesConfig(registriesConfig)
+  );
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl);
+  assertRegistriesConfig(registriesConfig);
 
-  logger.debug(`reading project package.json`)
-  const packageInProject = readProjectPackage({ rootDirectoryUrl })
+  logger.debug(`reading project package.json`);
+  const packageInProject = readProjectPackage({ rootDirectoryUrl });
 
-  const { name: packageName, version: packageVersion } = packageInProject
-  logger.info(`${packageName}@${packageVersion} found in package.json`)
+  const { name: packageName, version: packageVersion } = packageInProject;
+  logger.info(`${packageName}@${packageVersion} found in package.json`);
 
-  const report = {}
+  const report = {};
   await Promise.all(
     Object.keys(registriesConfig).map(async (registryUrl) => {
       const registryReport = {
@@ -47,91 +47,91 @@ export const publishPackage = async ({
         action: undefined,
         actionReason: undefined,
         actionResult: undefined,
-      }
-      report[registryUrl] = registryReport
+      };
+      report[registryUrl] = registryReport;
 
       if (packageInProject.private) {
-        registryReport.action = "nothing"
-        registryReport.actionReason = "package is private"
-        return
+        registryReport.action = "nothing";
+        registryReport.actionReason = "package is private";
+        return;
       }
 
-      logger.debug(`check latest version for ${packageName} in ${registryUrl}`)
-      const registryConfig = registriesConfig[registryUrl]
+      logger.debug(`check latest version for ${packageName} in ${registryUrl}`);
+      const registryConfig = registriesConfig[registryUrl];
 
       try {
         const latestPackageInRegistry = await fetchLatestInRegistry({
           registryUrl,
           packageName,
           ...registryConfig,
-        })
+        });
         const registryLatestVersion =
           latestPackageInRegistry === null
             ? null
-            : latestPackageInRegistry.version
-        registryReport.registryLatestVersion = registryLatestVersion
+            : latestPackageInRegistry.version;
+        registryReport.registryLatestVersion = registryLatestVersion;
 
-        const needs = needsPublish({ packageVersion, registryLatestVersion })
+        const needs = needsPublish({ packageVersion, registryLatestVersion });
         registryReport.action =
           needs === PUBLISH_BECAUSE_NEVER_PUBLISHED ||
           needs === PUBLISH_BECAUSE_LATEST_LOWER ||
           needs === PUBLISH_BECAUSE_TAG_DIFFERS
             ? "publish"
-            : "nothing"
-        registryReport.actionReason = needs
+            : "nothing";
+        registryReport.actionReason = needs;
       } catch (e) {
-        registryReport.action = "nothing"
-        registryReport.actionReason = e
+        registryReport.action = "nothing";
+        registryReport.actionReason = e;
         if (updateProcessExitCode) {
-          process.exitCode = 1
+          process.exitCode = 1;
         }
       }
     }),
-  )
+  );
 
   // we have to publish in serie because we don't fully control
   // npm publish, we have to enforce where the package gets published
   await Object.keys(report).reduce(async (previous, registryUrl) => {
-    await previous
+    await previous;
 
-    const registryReport = report[registryUrl]
-    const { action, actionReason, registryLatestVersion } = registryReport
+    const registryReport = report[registryUrl];
+    const { action, actionReason, registryLatestVersion } = registryReport;
 
     if (action === "nothing") {
       if (actionReason === NOTHING_BECAUSE_ALREADY_PUBLISHED) {
         logger.info(
           `skip ${packageName}@${packageVersion} publish on ${registryUrl} because already published`,
-        )
+        );
       } else if (actionReason === NOTHING_BECAUSE_LATEST_HIGHER) {
         logger.info(
           `skip ${packageName}@${packageVersion} publish on ${registryUrl} because latest version is higher (${registryLatestVersion})`,
-        )
+        );
       } else if (actionReason === "package is private") {
         logger.info(
           `skip ${packageName}@${packageVersion} publish on ${registryUrl} because found private: true in package.json`,
-        )
+        );
       } else {
         logger.error(`skip ${packageName}@${packageVersion} publish on ${registryUrl} due to error while fetching latest version.
 --- error stack ---
-${actionReason.stack}`)
+${actionReason.stack}`);
       }
 
-      registryReport.actionResult = { success: true, reason: "nothing-to-do" }
-      return
+      registryReport.actionResult = { success: true, reason: "nothing-to-do" };
+      return;
     }
 
     if (actionReason === PUBLISH_BECAUSE_NEVER_PUBLISHED) {
       logger.info(
         `publish ${packageName}@${packageVersion} on ${registryUrl} because it was never published`,
-      )
+      );
     } else if (actionReason === PUBLISH_BECAUSE_LATEST_LOWER) {
       logger.info(
         `publish ${packageName}@${packageVersion} on ${registryUrl} because latest version is lower (${registryLatestVersion})`,
-      )
+      );
     } else if (actionReason === PUBLISH_BECAUSE_TAG_DIFFERS) {
       logger.info(
         `publish ${packageName}@${packageVersion} on ${registryUrl} because latest tag differs (${registryLatestVersion})`,
-      )
+      );
     }
 
     const { success, reason } = await publish({
@@ -141,27 +141,27 @@ ${actionReason.stack}`)
       rootDirectoryUrl,
       registryUrl,
       ...registriesConfig[registryUrl],
-    })
-    registryReport.actionResult = { success, reason }
+    });
+    registryReport.actionResult = { success, reason };
     if (!success && updateProcessExitCode) {
-      process.exitCode = 1
+      process.exitCode = 1;
     }
-  }, Promise.resolve())
+  }, Promise.resolve());
 
-  return report
-}
+  return report;
+};
 
 const assertRegistriesConfig = (value) => {
   if (typeof value !== "object" || value === null) {
-    throw new TypeError(`registriesConfig must be an object, got ${value}`)
+    throw new TypeError(`registriesConfig must be an object, got ${value}`);
   }
 
   Object.keys(value).forEach((registryUrl) => {
-    const registryMapValue = value[registryUrl]
+    const registryMapValue = value[registryUrl];
     if (typeof registryMapValue !== "object" || value === null) {
       throw new TypeError(
         `Unexpected value in registriesConfig for ${registryUrl}. It must be an object, got ${registryMapValue}`,
-      )
+      );
     }
 
     if (
@@ -170,14 +170,14 @@ const assertRegistriesConfig = (value) => {
     ) {
       throw new TypeError(
         `Missing token in registriesConfig for ${registryUrl}.`,
-      )
+      );
     }
 
-    const { token } = registryMapValue
+    const { token } = registryMapValue;
     if (typeof token !== "string") {
       throw new TypeError(
         `Unexpected token in registriesConfig for ${registryUrl}. It must be a string, got ${token}.`,
-      )
+      );
     }
-  })
-}
+  });
+};