More

Andarist · May 28, 2024 · May 21, 2024 · May 21, 2024 · May 21, 2024 · May 21, 2024
commit f8a292efaec7846d0493d059acd5590a16973ada
diff --git a/packages/apply-release-plan/src/index.ts b/packages/apply-release-plan/src/index.ts
@@ -9,7 +9,7 @@ import {
 import { defaultConfig } from "@changesets/config";
 import * as git from "@changesets/git";
 import resolveFrom from "resolve-from";
-import { Packages } from "@manypkg/get-packages";
+import { Package, Packages } from "@manypkg/get-packages";
 import detectIndent from "detect-indent";
 
 import fs from "fs-extra";
@@ -80,6 +80,11 @@ export default async function applyReleasePlan(
     packages.packages.map((x) => [x.packageJson.name, x])
   );
 
+  const isVersionablePackage = createIsVersionablePackage(
+    config.ignore,
+    config.privatePackages.version
+  );
+
   let { releases, changesets } = releasePlan;
 
   let releasesWithPackage = releases.map((release) => {
@@ -163,10 +168,10 @@ export default async function applyReleasePlan(
           // At this point, we know there is no such changeset, because otherwise the program would've already failed,
           // so we just check if any ignored package exists in this changeset, and only remove it if none exists
           // Ignored list is added in v2, so we don't need to do it for v1 changesets
-          // TODO(jakebailey): should this check isVersionablePackage?
           if (
-            !changeset.releases.find((release) =>
-              config.ignore.includes(release.name)
+            !changeset.releases.find(
+              (release) =>
+                !isVersionablePackage(packagesByName.get(release.name)!)
             )
           ) {
             touchedFiles.push(changesetPath);
@@ -185,6 +190,26 @@ export default async function applyReleasePlan(
   return touchedFiles;
 }
 
+// TODO(jakebailey): don't copy paste
+export function createIsVersionablePackage(
+  ignoredPackages: readonly string[],
+  allowPrivatePackages: boolean
+): (pkg: Package) => boolean {
+  const ignoredPackagesSet = new Set(ignoredPackages);
+  return ({ packageJson }: Package) => {
+    if (ignoredPackagesSet.has(packageJson.name)) {
+      return false;
+    }
+
+    if (packageJson.private && !allowPrivatePackages) {
+      return false;
+    }
+
+    const hasVersionField = !!packageJson.version;
+    return hasVersionField;
+  };
+}
+
 async function getNewChangelogEntry(
   releasesWithPackage: ModCompWithPackage[],
   changesets: NewChangeset[],

diff --git a/packages/assemble-release-plan/src/determine-dependents.ts b/packages/assemble-release-plan/src/determine-dependents.ts
@@ -8,7 +8,7 @@ import {
 import { Package } from "@manypkg/get-packages";
 import { InternalRelease, PreInfo } from "./types";
 import { incrementVersion } from "./increment";
-import { isVersionablePackage } from "./utils";
+import { createIsVersionablePackage } from "./utils";
 
 /*
   WARNING:
@@ -38,10 +38,10 @@ export default function determineDependents({
   let updated = false;
   // NOTE this is intended to be called recursively
   let pkgsToSearch = [...releases.values()];
-  const isVersionablePackageOptions = {
-    ignoredPackages: new Set(config.ignore),
-    versionPrivatePackages: config.privatePackages.version,
-  };
+  const isVersionablePackage = createIsVersionablePackage(
+    config.ignore,
+    config.privatePackages.version
+  );
 
   while (pkgsToSearch.length > 0) {
     // nextRelease is our dependency, think of it as "avatar"
@@ -61,9 +61,7 @@ export default function determineDependents({
         const dependentPackage = packagesByName.get(dependent);
         if (!dependentPackage) throw new Error("Dependency map is incorrect");
 
-        if (
-          !isVersionablePackage(dependentPackage, isVersionablePackageOptions)
-        ) {
+        if (!isVersionablePackage(dependentPackage)) {
           type = "none";
         } else {
           const dependencyVersionRanges = getDependencyVersionRanges(

diff --git a/packages/assemble-release-plan/src/flatten-releases.ts b/packages/assemble-release-plan/src/flatten-releases.ts
@@ -8,16 +8,15 @@ import { InternalRelease } from "./types";
 export default function flattenReleases(
   changesets: NewChangeset[],
   packagesByName: Map<string, Package>,
-  ignoredPackages: Readonly<string[]>
+  isVersionablePackage: (pkg: Package) => boolean
 ): Map<string, InternalRelease> {
   let releases: Map<string, InternalRelease> = new Map();
 
   changesets.forEach((changeset) => {
     changeset.releases
       // Filter out ignored packages because they should not trigger a release
       // If their dependencies need updates, they will be added to releases by `determineDependents()` with release type `none`
-      // TODO(jakebailey): should this check isVersionablePackage?
-      .filter(({ name }) => !ignoredPackages.includes(name))
+      .filter(({ name }) => isVersionablePackage(packagesByName.get(name)!))
       .forEach(({ name, type }) => {
         let release = releases.get(name);
         let pkg = packagesByName.get(name);

diff --git a/packages/assemble-release-plan/src/index.ts b/packages/assemble-release-plan/src/index.ts
@@ -15,7 +15,7 @@ import { InternalError } from "@changesets/errors";
 import { Packages, Package } from "@manypkg/get-packages";
 import { getDependentsGraph } from "@changesets/get-dependents-graph";
 import { PreInfo, InternalRelease } from "./types";
-import { isVersionablePackage } from "./utils";
+import { createIsVersionablePackage } from "./utils";
 
 type SnapshotReleaseParameters = {
   tag?: string | undefined;
@@ -155,14 +155,15 @@ function assembleReleasePlan(
     packages.packages.map((x) => [x.packageJson.name, x])
   );
 
-  const isVersionablePackageOptions = {
-    ignoredPackages: new Set(config.ignore),
-    versionPrivatePackages: config.privatePackages.version,
-  };
+  const isVersionablePackage = createIsVersionablePackage(
+    config.ignore,
+    config.privatePackages.version
+  );
 
   const relevantChangesets = getRelevantChangesets(
     changesets,
-    refinedConfig.ignore,
+    packagesByName,
+    isVersionablePackage,
     preState
   );
 
@@ -179,7 +180,7 @@ function assembleReleasePlan(
   let releases = flattenReleases(
     relevantChangesets,
     packagesByName,
-    refinedConfig.ignore
+    isVersionablePackage
   );
 
   let dependencyGraph = getDependentsGraph(packages, {
@@ -230,7 +231,7 @@ function assembleReleasePlan(
           });
         } else if (
           existingRelease.type === "none" &&
-          !isVersionablePackage(pkg, isVersionablePackageOptions)
+          !isVersionablePackage(pkg)
         ) {
           existingRelease.type = "patch";
         }
@@ -267,7 +268,8 @@ function assembleReleasePlan(
 
 function getRelevantChangesets(
   changesets: NewChangeset[],
-  ignored: Readonly<string[]>,
+  packagesByName: Map<string, Package>,
+  isVersionablePackage: (pkg: Package) => boolean,
   preState: PreState | undefined
 ): NewChangeset[] {
   for (const changeset of changesets) {
@@ -276,12 +278,7 @@ function getRelevantChangesets(
     const ignoredPackages = [];
     const notIgnoredPackages = [];
     for (const release of changeset.releases) {
-      // TODO(jakebailey): should this check isVersionablePackage?
-      if (
-        ignored.find(
-          (ignoredPackageName) => ignoredPackageName === release.name
-        )
-      ) {
+      if (!isVersionablePackage(packagesByName.get(release.name)!)) {
         ignoredPackages.push(release.name);
       } else {
         notIgnoredPackages.push(release.name);

diff --git a/packages/assemble-release-plan/src/match-fixed-constraint.ts b/packages/assemble-release-plan/src/match-fixed-constraint.ts
@@ -2,9 +2,9 @@ import { Config } from "@changesets/types";
 import { Package } from "@manypkg/get-packages";
 import { InternalRelease } from "./types";
 import {
+  createIsVersionablePackage,
   getCurrentHighestVersion,
   getHighestReleaseType,
-  isVersionablePackage,
 } from "./utils";
 
 export default function matchFixedConstraint(
@@ -14,10 +14,10 @@ export default function matchFixedConstraint(
 ): boolean {
   let updated = false;
 
-  const isVersionablePackageOptions = {
-    ignoredPackages: new Set(config.ignore),
-    versionPrivatePackages: config.privatePackages.version,
-  };
+  const isVersionablePackage = createIsVersionablePackage(
+    config.ignore,
+    config.privatePackages.version
+  );
 
   for (let fixedPackages of config.fixed) {
     let releasingFixedPackages = [...releases.values()].filter(
@@ -35,8 +35,7 @@ export default function matchFixedConstraint(
 
     // Finally, we update the packages so all of them are on the highest version
     for (let pkgName of fixedPackages) {
-      const pkg = packagesByName.get(pkgName);
-      if (pkg && !isVersionablePackage(pkg, isVersionablePackageOptions)) {
+      if (!isVersionablePackage(packagesByName.get(pkgName)!)) {
         continue;
       }
       let release = releases.get(pkgName);

diff --git a/packages/assemble-release-plan/src/utils.ts b/packages/assemble-release-plan/src/utils.ts
@@ -60,24 +60,21 @@ export function getCurrentHighestVersion(
 }
 
 // TODO(jakebailey): don't copy paste
-export function isVersionablePackage(
-  { packageJson }: Package,
-  {
-    ignoredPackages,
-    versionPrivatePackages,
-  }: {
-    ignoredPackages: Set<string>;
-    versionPrivatePackages: boolean;
-  }
-) {
-  if (ignoredPackages.has(packageJson.name)) {
-    return false;
-  }
+export function createIsVersionablePackage(
+  ignoredPackages: readonly string[],
+  allowPrivatePackages: boolean
+): (pkg: Package) => boolean {
+  const ignoredPackagesSet = new Set(ignoredPackages);
+  return ({ packageJson }: Package) => {
+    if (ignoredPackagesSet.has(packageJson.name)) {
+      return false;
+    }
 
-  if (packageJson.private && !versionPrivatePackages) {
-    return false;
-  }
+    if (packageJson.private && !allowPrivatePackages) {
+      return false;
+    }
 
-  const hasVersionField = !!packageJson.version;
-  return hasVersionField;
+    const hasVersionField = !!packageJson.version;
+    return hasVersionField;
+  };
 }