From 7022eaf524a4e69b1557a4f4ad40a1cad4b289b9 Mon Sep 17 00:00:00 2001 From: jk Date: Tue, 28 May 2024 16:15:51 +0200 Subject: [PATCH 1/3] nix flake update + pnpm@9.1.3 Note: Latest pnpm@9.1.3 is not part of nixpkg (yet) and needs set (overridden) manually --- flake.lock | 10 +++++----- flake.nix | 8 +++++++- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/flake.lock b/flake.lock index bb5ed632c..ddad17545 100644 --- a/flake.lock +++ b/flake.lock @@ -2,12 +2,12 @@ "nodes": { "nixpkgs": { "locked": { - "lastModified": 1711523803, - "narHash": "sha256-UKcYiHWHQynzj6CN/vTcix4yd1eCu1uFdsuarupdCQQ=", - "rev": "2726f127c15a4cc9810843b96cad73c7eb39e443", - "revCount": 603596, + "lastModified": 1716509168, + "narHash": "sha256-4zSIhSRRIoEBwjbPm3YiGtbd8HDWzFxJjw5DYSDy1n8=", + "rev": "bfb7a882678e518398ce9a31a881538679f6f092", + "revCount": 630835, "type": "tarball", - "url": "https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.1.603596%2Brev-2726f127c15a4cc9810843b96cad73c7eb39e443/018e832d-3843-724d-abbf-1db8b877f613/source.tar.gz" + "url": "https://api.flakehub.com/f/pinned/NixOS/nixpkgs/0.1.630835%2Brev-bfb7a882678e518398ce9a31a881538679f6f092/018fafb0-ec0d-7254-8082-b09ecc86e5fc/source.tar.gz" }, "original": { "type": "tarball", diff --git a/flake.nix b/flake.nix index ddb81b01e..e1df3b8da 100644 --- a/flake.nix +++ b/flake.nix @@ -8,7 +8,13 @@ overlays = [ (final: prev: rec { nodejs = prev.nodejs_18; - pnpm = prev.nodePackages.pnpm; + pnpm = prev.nodePackages.pnpm.override rec { + version = "9.1.3"; + src = prev.fetchurl { + url = "https://registry.npmjs.org/pnpm/-/pnpm-${version}.tgz"; + sha256 = "sha256-f2MAHtwHfxz/lsrLqQHzUHlih6KADfqD/omPlBg+T18="; + }; + }; }) ]; supportedSystems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ]; From c1ca20f61ea0d68cfa5ef5126826c20c7cae2d87 Mon Sep 17 00:00:00 2001 From: Daniel Steigerwald Date: Tue, 28 May 2024 17:18:05 +0200 Subject: [PATCH 2/3] Fix install --- package.json | 3 -- pnpm-lock.yaml | 85 +++++++++++++++++++++++++++----------------------- 2 files changed, 46 insertions(+), 42 deletions(-) diff --git a/package.json b/package.json index ae6dcc91e..303e7452a 100755 --- a/package.json +++ b/package.json @@ -28,9 +28,6 @@ }, "packageManager": "pnpm@9.1.3", "pnpm": { - "patchedDependencies": { - "@changesets/assemble-release-plan@6.0.0": "patches/@changesets__assemble-release-plan@6.0.0.patch" - }, "peerDependencyRules": { "ignoreMissing": [ "@babel/*", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 41c9815b8..224d37c79 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -7,18 +7,13 @@ settings: overrides: flexsearch: 0.7.31 -patchedDependencies: - '@changesets/assemble-release-plan@6.0.0': - hash: efefrufcathrfopd2z6l62idva - path: patches/@changesets__assemble-release-plan@6.0.0.patch - importers: .: devDependencies: '@changesets/cli': specifier: ^2.27.3 - version: 2.27.3 + version: 2.27.4 eslint: specifier: ^8.57.0 version: 8.57.0 @@ -1256,17 +1251,17 @@ packages: '@braintree/sanitize-url@6.0.4': resolution: {integrity: sha512-s3jaWicZd0pkP0jf5ysyHUI/RE7MHos6qlToFcGWXVp+ykHOy77OUMrfbgJ9it2C5bow7OIQwYYaHjk9XlBQ2A==} - '@changesets/apply-release-plan@7.0.1': - resolution: {integrity: sha512-aPdSq/R++HOyfEeBGjEe6LNG8gs0KMSyRETD/J2092OkNq8mOioAxyKjMbvVUdzgr/HTawzMOz7lfw339KnsCA==} + '@changesets/apply-release-plan@7.0.2': + resolution: {integrity: sha512-lRdN9c8e2zbzSWTGK3HzlNATPWETBy6tMvf4MENUzb7OQD3kFQ+dVKCJtj42pLWRjLn2flbLofEK04k92GEttg==} - '@changesets/assemble-release-plan@6.0.0': - resolution: {integrity: sha512-4QG7NuisAjisbW4hkLCmGW2lRYdPrKzro+fCtZaILX+3zdUELSvYjpL4GTv0E4aM9Mef3PuIQp89VmHJ4y2bfw==} + '@changesets/assemble-release-plan@6.0.1': + resolution: {integrity: sha512-VXKjqGomnj4evJ/B6ENUFMxV+EV/LDkdWl2+8NjCcGo4Rn/aogjofCDLWbWEhtjtgLUdwvlsoydibIDOf/abvA==} '@changesets/changelog-git@0.2.0': resolution: {integrity: sha512-bHOx97iFI4OClIT35Lok3sJAwM31VbUM++gnMBV16fdbtBhgYu4dxsphBF/0AZZsyAHMrnM0yFcj5gZM1py6uQ==} - '@changesets/cli@2.27.3': - resolution: {integrity: sha512-ve/VpWApILlSs8cr0okNx5C2LKRawI9XZgvfmf58S8sar2nhx5DPJREFXYZBahs0FeTfvH0rdVl+nGe8QF45Ig==} + '@changesets/cli@2.27.4': + resolution: {integrity: sha512-X3Nd9cBoyuykjmMJnRFHik26UoA5y4ikhds4BJE0IGKpnIvkV8gRqyZE6Tcmc3zuS5GXfCmGnyJXVwxe89uX5A==} hasBin: true '@changesets/config@3.0.0': @@ -1278,8 +1273,8 @@ packages: '@changesets/get-dependents-graph@2.0.0': resolution: {integrity: sha512-cafUXponivK4vBgZ3yLu944mTvam06XEn2IZGjjKc0antpenkYANXiiE6GExV/yKdsCnE8dXVZ25yGqLYZmScA==} - '@changesets/get-release-plan@4.0.0': - resolution: {integrity: sha512-9L9xCUeD/Tb6L/oKmpm8nyzsOzhdNBBbt/ZNcjynbHC07WW4E1eX8NMGC5g5SbM5z/V+MOrYsJ4lRW41GCbg3w==} + '@changesets/get-release-plan@4.0.1': + resolution: {integrity: sha512-1zojjyxeIzIHA/zWXZ3XYxKySBDtbTP9PS6EZLrM0r1luq8Oy7U0zBq/I9NX77qVJV9EF3cO4KP5pfRHorSLTg==} '@changesets/get-version-range-type@0.4.0': resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==} @@ -1299,6 +1294,9 @@ packages: '@changesets/read@0.6.0': resolution: {integrity: sha512-ZypqX8+/im1Fm98K4YcZtmLKgjs1kDQ5zHpc2U1qdtNBmZZfo/IBiG162RoP0CUF05tvp2y4IspH11PLnPxuuw==} + '@changesets/should-skip-package@0.1.0': + resolution: {integrity: sha512-FxG6Mhjw7yFStlSM7Z0Gmg3RiyQ98d/9VpQAZ3Fzr59dCOM9G6ZdYbjiSAt0XtFr9JR5U2tBaJWPjrkGGc618g==} + '@changesets/types@4.1.0': resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==} @@ -2039,8 +2037,8 @@ packages: '@segment/loosely-validate-event@2.0.0': resolution: {integrity: sha512-ZMCSfztDBqwotkl848ODgVcAmN4OItEWDCkshcKz0/W6gGSQayuuCtWV/MlodFivAZD793d6UgANd6wCXUfrIw==} - '@shikijs/core@1.6.0': - resolution: {integrity: sha512-NIEAi5U5R7BLkbW1pG/ZKu3eb1lzc3/+jD0lFsuxMT7zjaf9bbNwdNyMr7zh/Zl8EXQtQ+MYBAt5G+JLu+5DlA==} + '@shikijs/core@1.6.1': + resolution: {integrity: sha512-CqYyepN4SnBopaoXYwng4NO8riB5ask/LTCkhOFq+GNGtr2X+aKeD767eYdqYukeixEUvv4bXdyTYVaogj7KBw==} '@sideway/address@4.1.5': resolution: {integrity: sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==} @@ -6570,8 +6568,8 @@ packages: shiki@0.14.7: resolution: {integrity: sha512-dNPAPrxSc87ua2sKJ3H5dQ/6ZaY8RNnaAqK+t0eG7p0Soi2ydiqbGOTaZCqaYvA/uZYfS1LJnemt3Q+mSfcPCg==} - shiki@1.6.0: - resolution: {integrity: sha512-P31ROeXcVgW/k3Z+vUUErcxoTah7ZRaimctOpzGuqAntqnnSmx1HOsvnbAB8Z2qfXPRhw61yptAzCsuKOhTHwQ==} + shiki@1.6.1: + resolution: {integrity: sha512-1Pu/A1rtsG6HZvQm4W0NExQ45e02og+rPog7PDaFDiMumZgOYnZIu4JtGQeAIfMwdbKSjJQoCUr79vDLKUUxWA==} side-channel@1.0.6: resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} @@ -7146,8 +7144,8 @@ packages: engines: {node: '>=14.17'} hasBin: true - ua-parser-js@1.0.37: - resolution: {integrity: sha512-bhTyI94tZofjo+Dn8SN6Zv8nBDvyXTymAdM3LDI/0IboIUwTu1rEhW7v2TfiVsoYWgkQ4kOVqnI8APUFbIQIFQ==} + ua-parser-js@1.0.38: + resolution: {integrity: sha512-Aq5ppTOfvrCMgAPneW1HfWj66Xi7XL+/mIy996R1/CLS/rcyJQm6QZdsKrUeivDFQ+Oc9Wyuwor8Ze8peEoUoQ==} uc.micro@2.1.0: resolution: {integrity: sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==} @@ -7344,8 +7342,8 @@ packages: engines: {node: ^18.0.0 || >=20.0.0} hasBin: true - vite@5.2.11: - resolution: {integrity: sha512-HndV31LWW05i1BLPMUCE1B9E9GFbOu1MbenhS58FuK6owSO5qHm7GiCotrNY1YE5rMeQSFBGmT5ZaLEjFizgiQ==} + vite@5.2.12: + resolution: {integrity: sha512-/gC8GxzxMK5ntBwb48pR32GGhENnjtY30G4A0jemunsBkiEZFw60s8InGpN8gkhHEkjnRK1aSAxeQgwvFhUHAA==} engines: {node: ^18.0.0 || >=20.0.0} hasBin: true peerDependencies: @@ -8519,12 +8517,13 @@ snapshots: '@braintree/sanitize-url@6.0.4': {} - '@changesets/apply-release-plan@7.0.1': + '@changesets/apply-release-plan@7.0.2': dependencies: '@babel/runtime': 7.24.6 '@changesets/config': 3.0.0 '@changesets/get-version-range-type': 0.4.0 '@changesets/git': 3.0.0 + '@changesets/should-skip-package': 0.1.0 '@changesets/types': 6.0.0 '@manypkg/get-packages': 1.1.3 detect-indent: 6.1.0 @@ -8535,11 +8534,12 @@ snapshots: resolve-from: 5.0.0 semver: 7.6.2 - '@changesets/assemble-release-plan@6.0.0(patch_hash=efefrufcathrfopd2z6l62idva)': + '@changesets/assemble-release-plan@6.0.1': dependencies: '@babel/runtime': 7.24.6 '@changesets/errors': 0.2.0 '@changesets/get-dependents-graph': 2.0.0 + '@changesets/should-skip-package': 0.1.0 '@changesets/types': 6.0.0 '@manypkg/get-packages': 1.1.3 semver: 7.6.2 @@ -8548,20 +8548,21 @@ snapshots: dependencies: '@changesets/types': 6.0.0 - '@changesets/cli@2.27.3': + '@changesets/cli@2.27.4': dependencies: '@babel/runtime': 7.24.6 - '@changesets/apply-release-plan': 7.0.1 - '@changesets/assemble-release-plan': 6.0.0(patch_hash=efefrufcathrfopd2z6l62idva) + '@changesets/apply-release-plan': 7.0.2 + '@changesets/assemble-release-plan': 6.0.1 '@changesets/changelog-git': 0.2.0 '@changesets/config': 3.0.0 '@changesets/errors': 0.2.0 '@changesets/get-dependents-graph': 2.0.0 - '@changesets/get-release-plan': 4.0.0 + '@changesets/get-release-plan': 4.0.1 '@changesets/git': 3.0.0 '@changesets/logger': 0.1.0 '@changesets/pre': 2.0.0 '@changesets/read': 0.6.0 + '@changesets/should-skip-package': 0.1.0 '@changesets/types': 6.0.0 '@changesets/write': 0.3.1 '@manypkg/get-packages': 1.1.3 @@ -8605,10 +8606,10 @@ snapshots: fs-extra: 7.0.1 semver: 7.6.2 - '@changesets/get-release-plan@4.0.0': + '@changesets/get-release-plan@4.0.1': dependencies: '@babel/runtime': 7.24.6 - '@changesets/assemble-release-plan': 6.0.0(patch_hash=efefrufcathrfopd2z6l62idva) + '@changesets/assemble-release-plan': 6.0.1 '@changesets/config': 3.0.0 '@changesets/pre': 2.0.0 '@changesets/read': 0.6.0 @@ -8655,6 +8656,12 @@ snapshots: fs-extra: 7.0.1 p-filter: 2.1.0 + '@changesets/should-skip-package@0.1.0': + dependencies: + '@babel/runtime': 7.24.6 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + '@changesets/types@4.1.0': {} '@changesets/types@6.0.0': {} @@ -9734,7 +9741,7 @@ snapshots: component-type: 1.2.2 join-component: 1.1.0 - '@shikijs/core@1.6.0': {} + '@shikijs/core@1.6.1': {} '@sideway/address@4.1.5': dependencies: @@ -12034,7 +12041,7 @@ snapshots: object-assign: 4.1.1 promise: 7.3.1 setimmediate: 1.0.5 - ua-parser-js: 1.0.37 + ua-parser-js: 1.0.38 transitivePeerDependencies: - encoding @@ -15386,9 +15393,9 @@ snapshots: vscode-oniguruma: 1.7.0 vscode-textmate: 8.0.0 - shiki@1.6.0: + shiki@1.6.1: dependencies: - '@shikijs/core': 1.6.0 + '@shikijs/core': 1.6.1 side-channel@1.0.6: dependencies: @@ -15982,7 +15989,7 @@ snapshots: lunr: 2.3.9 markdown-it: 14.1.0 minimatch: 9.0.4 - shiki: 1.6.0 + shiki: 1.6.1 typescript: 5.4.5 yaml: 2.4.2 @@ -15990,7 +15997,7 @@ snapshots: typescript@5.4.5: {} - ua-parser-js@1.0.37: {} + ua-parser-js@1.0.38: {} uc.micro@2.1.0: {} @@ -16220,7 +16227,7 @@ snapshots: debug: 4.3.4 pathe: 1.1.2 picocolors: 1.0.1 - vite: 5.2.11(@types/node@20.12.12)(terser@5.31.0) + vite: 5.2.12(@types/node@20.12.12)(terser@5.31.0) transitivePeerDependencies: - '@types/node' - less @@ -16231,7 +16238,7 @@ snapshots: - supports-color - terser - vite@5.2.11(@types/node@20.12.12)(terser@5.31.0): + vite@5.2.12(@types/node@20.12.12)(terser@5.31.0): dependencies: esbuild: 0.20.2 postcss: 8.4.38 @@ -16260,7 +16267,7 @@ snapshots: strip-literal: 2.1.0 tinybench: 2.8.0 tinypool: 0.8.4 - vite: 5.2.11(@types/node@20.12.12)(terser@5.31.0) + vite: 5.2.12(@types/node@20.12.12)(terser@5.31.0) vite-node: 1.6.0(@types/node@20.12.12)(terser@5.31.0) why-is-node-running: 2.2.2 optionalDependencies: From e42af18095f1f7005808276d4b968b08650c0a8f Mon Sep 17 00:00:00 2001 From: Daniel Steigerwald Date: Tue, 28 May 2024 17:26:46 +0200 Subject: [PATCH 3/3] Update changesets patch --- package.json | 3 + ...ngesets__assemble-release-plan@6.0.0.patch | 42 - ...ngesets__assemble-release-plan@6.0.1.patch | 1669 +++++++++++++++++ pnpm-lock.yaml | 11 +- 4 files changed, 1680 insertions(+), 45 deletions(-) delete mode 100644 patches/@changesets__assemble-release-plan@6.0.0.patch create mode 100644 patches/@changesets__assemble-release-plan@6.0.1.patch diff --git a/package.json b/package.json index 303e7452a..7d5a248fb 100755 --- a/package.json +++ b/package.json @@ -37,6 +37,9 @@ }, "overrides": { "flexsearch": "0.7.31" + }, + "patchedDependencies": { + "@changesets/assemble-release-plan@6.0.1": "patches/@changesets__assemble-release-plan@6.0.1.patch" } } } diff --git a/patches/@changesets__assemble-release-plan@6.0.0.patch b/patches/@changesets__assemble-release-plan@6.0.0.patch deleted file mode 100644 index e6c8faa6a..000000000 --- a/patches/@changesets__assemble-release-plan@6.0.0.patch +++ /dev/null @@ -1,42 +0,0 @@ -diff --git a/dist/changesets-assemble-release-plan.cjs.js b/dist/changesets-assemble-release-plan.cjs.js -index ee5c0f67fabadeb112e9f238d8b144a4d125830f..42afcbce044a2949d6242af0a6c5abffcd2a51ad 100644 ---- a/dist/changesets-assemble-release-plan.cjs.js -+++ b/dist/changesets-assemble-release-plan.cjs.js -@@ -90,16 +90,6 @@ function determineDependents({ - } of dependencyVersionRanges) { - if (nextRelease.type === "none") { - continue; -- } else if (shouldBumpMajor({ -- dependent, -- depType, -- versionRange, -- releases, -- nextRelease, -- preInfo, -- onlyUpdatePeerDependentsWhenOutOfRange: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.onlyUpdatePeerDependentsWhenOutOfRange -- })) { -- type = "major"; - } else if ((!releases.has(dependent) || releases.get(dependent).type === "none") && (config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.updateInternalDependents === "always" || !semverSatisfies__default["default"](incrementVersion(nextRelease, preInfo), versionRange))) { - switch (depType) { - case "dependencies": -diff --git a/dist/changesets-assemble-release-plan.esm.js b/dist/changesets-assemble-release-plan.esm.js -index bf5202626a164a7780650d333983c3479b078689..27eea4d1d31c0e7ce8d56363c5a3437bbeb819a0 100644 ---- a/dist/changesets-assemble-release-plan.esm.js -+++ b/dist/changesets-assemble-release-plan.esm.js -@@ -79,16 +79,6 @@ function determineDependents({ - } of dependencyVersionRanges) { - if (nextRelease.type === "none") { - continue; -- } else if (shouldBumpMajor({ -- dependent, -- depType, -- versionRange, -- releases, -- nextRelease, -- preInfo, -- onlyUpdatePeerDependentsWhenOutOfRange: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.onlyUpdatePeerDependentsWhenOutOfRange -- })) { -- type = "major"; - } else if ((!releases.has(dependent) || releases.get(dependent).type === "none") && (config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.updateInternalDependents === "always" || !semverSatisfies(incrementVersion(nextRelease, preInfo), versionRange))) { - switch (depType) { - case "dependencies": diff --git a/patches/@changesets__assemble-release-plan@6.0.1.patch b/patches/@changesets__assemble-release-plan@6.0.1.patch new file mode 100644 index 000000000..af946a793 --- /dev/null +++ b/patches/@changesets__assemble-release-plan@6.0.1.patch @@ -0,0 +1,1669 @@ +diff --git a/dist/changesets-assemble-release-plan.cjs.js b/dist/changesets-assemble-release-plan.cjs.js +index 60427457c887f2d72168fecec83d79088c68e3a4..394d607a3c56d6f5142bc4a9db1bb6dfac41f540 100644 +--- a/dist/changesets-assemble-release-plan.cjs.js ++++ b/dist/changesets-assemble-release-plan.cjs.js +@@ -1,26 +1,30 @@ +-'use strict'; ++"use strict"; + +-Object.defineProperty(exports, '__esModule', { value: true }); ++Object.defineProperty(exports, "__esModule", { value: true }); + +-var _objectSpread = require('@babel/runtime/helpers/objectSpread2'); +-var errors = require('@changesets/errors'); +-var getDependentsGraph = require('@changesets/get-dependents-graph'); +-var shouldSkipPackage = require('@changesets/should-skip-package'); +-var semverParse = require('semver/functions/parse'); +-var semverGt = require('semver/functions/gt'); +-var semverSatisfies = require('semver/functions/satisfies'); +-var semverInc = require('semver/functions/inc'); ++var _objectSpread = require("@babel/runtime/helpers/objectSpread2"); ++var errors = require("@changesets/errors"); ++var getDependentsGraph = require("@changesets/get-dependents-graph"); ++var shouldSkipPackage = require("@changesets/should-skip-package"); ++var semverParse = require("semver/functions/parse"); ++var semverGt = require("semver/functions/gt"); ++var semverSatisfies = require("semver/functions/satisfies"); ++var semverInc = require("semver/functions/inc"); + +-function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; } ++function _interopDefault(e) { ++ return e && e.__esModule ? e : { default: e }; ++} + +-var semverParse__default = /*#__PURE__*/_interopDefault(semverParse); +-var semverGt__default = /*#__PURE__*/_interopDefault(semverGt); +-var semverSatisfies__default = /*#__PURE__*/_interopDefault(semverSatisfies); +-var semverInc__default = /*#__PURE__*/_interopDefault(semverInc); ++var semverParse__default = /*#__PURE__*/ _interopDefault(semverParse); ++var semverGt__default = /*#__PURE__*/ _interopDefault(semverGt); ++var semverSatisfies__default = /*#__PURE__*/ _interopDefault(semverSatisfies); ++var semverInc__default = /*#__PURE__*/ _interopDefault(semverInc); + + function getHighestReleaseType(releases) { + if (releases.length === 0) { +- throw new Error(`Large internal Changesets error when calculating highest release type in the set of releases. Please contact the maintainers`); ++ throw new Error( ++ `Large internal Changesets error when calculating highest release type in the set of releases. Please contact the maintainers` ++ ); + } + + let highestReleaseType = "none"; +@@ -52,11 +56,16 @@ function getCurrentHighestVersion(packageGroup, packagesByName) { + let pkg = packagesByName.get(pkgName); + + if (!pkg) { +- console.error(`FATAL ERROR IN CHANGESETS! We were unable to version for package group: ${pkgName} in package group: ${packageGroup.toString()}`); ++ console.error( ++ `FATAL ERROR IN CHANGESETS! We were unable to version for package group: ${pkgName} in package group: ${packageGroup.toString()}` ++ ); + throw new Error(`fatal: could not resolve linked packages`); + } + +- if (highestVersion === undefined || semverGt__default["default"](pkg.packageJson.version, highestVersion)) { ++ if ( ++ highestVersion === undefined || ++ semverGt__default["default"](pkg.packageJson.version, highestVersion) ++ ) { + highestVersion = pkg.packageJson.version; + } + } +@@ -82,12 +91,18 @@ function applyLinks(releases, packagesByName, linked) { + + for (let linkedPackages of linked) { + // First we filter down to all the relevant releases for one set of linked packages +- let releasingLinkedPackages = [...releases.values()].filter(release => linkedPackages.includes(release.name) && release.type !== "none"); // If we proceed any further we do extra work with calculating highestVersion for things that might ++ let releasingLinkedPackages = [...releases.values()].filter( ++ (release) => ++ linkedPackages.includes(release.name) && release.type !== "none" ++ ); // If we proceed any further we do extra work with calculating highestVersion for things that might + // not need one, as they only have workspace based packages + + if (releasingLinkedPackages.length === 0) continue; + let highestReleaseType = getHighestReleaseType(releasingLinkedPackages); +- let highestVersion = getCurrentHighestVersion(linkedPackages, packagesByName); // Finally, we update the packages so all of them are on the highest version ++ let highestVersion = getCurrentHighestVersion( ++ linkedPackages, ++ packagesByName ++ ); // Finally, we update the packages so all of them are on the highest version + + for (let linkedPackage of releasingLinkedPackages) { + if (linkedPackage.type !== highestReleaseType) { +@@ -116,11 +131,12 @@ function incrementVersion(release, preInfo) { + let preVersion = preInfo.preVersions.get(release.name); + + if (preVersion === undefined) { +- throw new errors.InternalError(`preVersion for ${release.name} does not exist when preState is defined`); ++ throw new errors.InternalError( ++ `preVersion for ${release.name} does not exist when preState is defined` ++ ); + } // why are we adding this ourselves rather than passing 'pre' + versionType to semver.inc? + // because semver.inc with prereleases is confusing and this seems easier + +- + version += `-${preInfo.state.tag}.${preVersion}`; + } + +@@ -144,7 +160,7 @@ function determineDependents({ + packagesByName, + dependencyGraph, + preInfo, +- config ++ config, + }) { + let updated = false; // NOTE this is intended to be called recursively + +@@ -158,96 +174,101 @@ function determineDependents({ + const pkgDependents = dependencyGraph.get(nextRelease.name); + + if (!pkgDependents) { +- throw new Error(`Error in determining dependents - could not find package in repository: ${nextRelease.name}`); ++ throw new Error( ++ `Error in determining dependents - could not find package in repository: ${nextRelease.name}` ++ ); + } + +- pkgDependents.map(dependent => { +- let type; +- const dependentPackage = packagesByName.get(dependent); +- if (!dependentPackage) throw new Error("Dependency map is incorrect"); +- +- if (shouldSkipPackage.shouldSkipPackage(dependentPackage, { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })) { +- type = "none"; +- } else { +- const dependencyVersionRanges = getDependencyVersionRanges(dependentPackage.packageJson, nextRelease); +- +- for (const { +- depType, +- versionRange +- } of dependencyVersionRanges) { +- if (nextRelease.type === "none") { +- continue; +- } else if (shouldBumpMajor({ +- dependent, +- depType, +- versionRange, +- releases, +- nextRelease, +- preInfo, +- onlyUpdatePeerDependentsWhenOutOfRange: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.onlyUpdatePeerDependentsWhenOutOfRange +- })) { +- type = "major"; +- } else if ((!releases.has(dependent) || releases.get(dependent).type === "none") && (config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.updateInternalDependents === "always" || !semverSatisfies__default["default"](incrementVersion(nextRelease, preInfo), versionRange))) { +- switch (depType) { +- case "dependencies": +- case "optionalDependencies": +- case "peerDependencies": +- if (type !== "major" && type !== "minor") { +- type = "patch"; +- } ++ pkgDependents ++ .map((dependent) => { ++ let type; ++ const dependentPackage = packagesByName.get(dependent); ++ if (!dependentPackage) throw new Error("Dependency map is incorrect"); ++ ++ if ( ++ shouldSkipPackage.shouldSkipPackage(dependentPackage, { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) { ++ type = "none"; ++ } else { ++ const dependencyVersionRanges = getDependencyVersionRanges( ++ dependentPackage.packageJson, ++ nextRelease ++ ); ++ ++ for (const { depType, versionRange } of dependencyVersionRanges) { ++ if (nextRelease.type === "none") { ++ continue; ++ } else if ( ++ (!releases.has(dependent) || ++ releases.get(dependent).type === "none") && ++ (config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH ++ .updateInternalDependents === "always" || ++ !semverSatisfies__default["default"]( ++ incrementVersion(nextRelease, preInfo), ++ versionRange ++ )) ++ ) { ++ switch (depType) { ++ case "dependencies": ++ case "optionalDependencies": ++ case "peerDependencies": ++ if (type !== "major" && type !== "minor") { ++ type = "patch"; ++ } + +- break; ++ break; + +- case "devDependencies": +- { ++ case "devDependencies": { + // We don't need a version bump if the package is only in the devDependencies of the dependent package +- if (type !== "major" && type !== "minor" && type !== "patch") { ++ if ( ++ type !== "major" && ++ type !== "minor" && ++ type !== "patch" ++ ) { + type = "none"; + } + } ++ } + } + } + } +- } + +- if (releases.has(dependent) && releases.get(dependent).type === type) { +- type = undefined; +- } ++ if (releases.has(dependent) && releases.get(dependent).type === type) { ++ type = undefined; ++ } + +- return { +- name: dependent, +- type, +- pkgJSON: dependentPackage.packageJson +- }; +- }).filter(dependentItem => !!dependentItem.type).forEach(({ +- name, +- type, +- pkgJSON +- }) => { +- // At this point, we know if we are making a change +- updated = true; +- const existing = releases.get(name); // For things that are being given a major bump, we check if we have already +- // added them here. If we have, we update the existing item instead of pushing it on to search. +- // It is safe to not add it to pkgsToSearch because it should have already been searched at the +- // largest possible bump type. +- +- if (existing && type === "major" && existing.type !== "major") { +- existing.type = "major"; +- pkgsToSearch.push(existing); +- } else { +- let newDependent = { +- name, ++ return { ++ name: dependent, + type, +- oldVersion: pkgJSON.version, +- changesets: [] ++ pkgJSON: dependentPackage.packageJson, + }; +- pkgsToSearch.push(newDependent); +- releases.set(name, newDependent); +- } +- }); ++ }) ++ .filter((dependentItem) => !!dependentItem.type) ++ .forEach(({ name, type, pkgJSON }) => { ++ // At this point, we know if we are making a change ++ updated = true; ++ const existing = releases.get(name); // For things that are being given a major bump, we check if we have already ++ // added them here. If we have, we update the existing item instead of pushing it on to search. ++ // It is safe to not add it to pkgsToSearch because it should have already been searched at the ++ // largest possible bump type. ++ ++ if (existing && type === "major" && existing.type !== "major") { ++ existing.type = "major"; ++ pkgsToSearch.push(existing); ++ } else { ++ let newDependent = { ++ name, ++ type, ++ oldVersion: pkgJSON.version, ++ changesets: [], ++ }; ++ pkgsToSearch.push(newDependent); ++ releases.set(name, newDependent); ++ } ++ }); + } + + return updated; +@@ -259,27 +280,38 @@ function determineDependents({ + */ + + function getDependencyVersionRanges(dependentPkgJSON, dependencyRelease) { +- const DEPENDENCY_TYPES = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]; ++ const DEPENDENCY_TYPES = [ ++ "dependencies", ++ "devDependencies", ++ "peerDependencies", ++ "optionalDependencies", ++ ]; + const dependencyVersionRanges = []; + + for (const type of DEPENDENCY_TYPES) { + var _dependentPkgJSON$typ; + +- const versionRange = (_dependentPkgJSON$typ = dependentPkgJSON[type]) === null || _dependentPkgJSON$typ === void 0 ? void 0 : _dependentPkgJSON$typ[dependencyRelease.name]; ++ const versionRange = ++ (_dependentPkgJSON$typ = dependentPkgJSON[type]) === null || ++ _dependentPkgJSON$typ === void 0 ++ ? void 0 ++ : _dependentPkgJSON$typ[dependencyRelease.name]; + if (!versionRange) continue; + + if (versionRange.startsWith("workspace:")) { + dependencyVersionRanges.push({ + depType: type, +- versionRange: // intentionally keep other workspace ranges untouched +- // this has to be fixed but this should only be done when adding appropriate tests +- versionRange === "workspace:*" ? // workspace:* actually means the current exact version, and not a wildcard similar to a reguler * range +- dependencyRelease.oldVersion : versionRange.replace(/^workspace:/, "") ++ // intentionally keep other workspace ranges untouched ++ versionRange: ++ // this has to be fixed but this should only be done when adding appropriate tests ++ versionRange === "workspace:*" // workspace:* actually means the current exact version, and not a wildcard similar to a reguler * range ++ ? dependencyRelease.oldVersion ++ : versionRange.replace(/^workspace:/, ""), + }); + } else { + dependencyVersionRanges.push({ + depType: type, +- versionRange ++ versionRange, + }); + } + } +@@ -294,57 +326,70 @@ function shouldBumpMajor({ + releases, + nextRelease, + preInfo, +- onlyUpdatePeerDependentsWhenOutOfRange ++ onlyUpdatePeerDependentsWhenOutOfRange, + }) { + // we check if it is a peerDependency because if it is, our dependent bump type might need to be major. +- return depType === "peerDependencies" && nextRelease.type !== "none" && nextRelease.type !== "patch" && ( // 1. If onlyUpdatePeerDependentsWhenOutOfRange set to true, bump major if the version is leaving the range. +- // 2. If onlyUpdatePeerDependentsWhenOutOfRange set to false, bump major regardless whether or not the version is leaving the range. +- !onlyUpdatePeerDependentsWhenOutOfRange || !semverSatisfies__default["default"](incrementVersion(nextRelease, preInfo), versionRange)) && ( // bump major only if the dependent doesn't already has a major release. +- !releases.has(dependent) || releases.has(dependent) && releases.get(dependent).type !== "major"); ++ return ( ++ depType === "peerDependencies" && ++ nextRelease.type !== "none" && ++ nextRelease.type !== "patch" && // 1. If onlyUpdatePeerDependentsWhenOutOfRange set to true, bump major if the version is leaving the range. ++ // 2. If onlyUpdatePeerDependentsWhenOutOfRange set to false, bump major regardless whether or not the version is leaving the range. ++ (!onlyUpdatePeerDependentsWhenOutOfRange || ++ !semverSatisfies__default["default"]( ++ incrementVersion(nextRelease, preInfo), ++ versionRange ++ )) && // bump major only if the dependent doesn't already has a major release. ++ (!releases.has(dependent) || ++ (releases.has(dependent) && releases.get(dependent).type !== "major")) ++ ); + } + + // This function takes in changesets and returns one release per + function flattenReleases(changesets, packagesByName, config) { + let releases = new Map(); +- changesets.forEach(changeset => { ++ changesets.forEach((changeset) => { + changeset.releases // Filter out skipped 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` +- .filter(({ +- name +- }) => !shouldSkipPackage.shouldSkipPackage(packagesByName.get(name), { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })).forEach(({ +- name, +- type +- }) => { +- let release = releases.get(name); +- let pkg = packagesByName.get(name); +- +- if (!pkg) { +- throw new Error(`"${changeset.id}" changeset mentions a release for a package "${name}" but such a package could not be found.`); +- } +- +- if (!release) { +- release = { +- name, +- type, +- oldVersion: pkg.packageJson.version, +- changesets: [changeset.id] +- }; +- } else { +- if (type === "major" || (release.type === "patch" || release.type === "none") && (type === "minor" || type === "patch")) { +- release.type = type; +- } // Check whether the bumpType will change +- // If the bumpType has changed recalc newVersion +- // push new changeset to releases +- ++ // If their dependencies need updates, they will be added to releases by `determineDependents()` with release type `none` ++ .filter( ++ ({ name }) => ++ !shouldSkipPackage.shouldSkipPackage(packagesByName.get(name), { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) ++ .forEach(({ name, type }) => { ++ let release = releases.get(name); ++ let pkg = packagesByName.get(name); ++ ++ if (!pkg) { ++ throw new Error( ++ `"${changeset.id}" changeset mentions a release for a package "${name}" but such a package could not be found.` ++ ); ++ } + +- release.changesets.push(changeset.id); +- } ++ if (!release) { ++ release = { ++ name, ++ type, ++ oldVersion: pkg.packageJson.version, ++ changesets: [changeset.id], ++ }; ++ } else { ++ if ( ++ type === "major" || ++ ((release.type === "patch" || release.type === "none") && ++ (type === "minor" || type === "patch")) ++ ) { ++ release.type = type; ++ } // Check whether the bumpType will change ++ // If the bumpType has changed recalc newVersion ++ // push new changeset to releases ++ ++ release.changesets.push(changeset.id); ++ } + +- releases.set(name, release); +- }); ++ releases.set(name, release); ++ }); + }); + return releases; + } +@@ -353,16 +398,24 @@ function matchFixedConstraint(releases, packagesByName, config) { + let updated = false; + + for (let fixedPackages of config.fixed) { +- let releasingFixedPackages = [...releases.values()].filter(release => fixedPackages.includes(release.name) && release.type !== "none"); ++ let releasingFixedPackages = [...releases.values()].filter( ++ (release) => ++ fixedPackages.includes(release.name) && release.type !== "none" ++ ); + if (releasingFixedPackages.length === 0) continue; + let highestReleaseType = getHighestReleaseType(releasingFixedPackages); +- let highestVersion = getCurrentHighestVersion(fixedPackages, packagesByName); // Finally, we update the packages so all of them are on the highest version ++ let highestVersion = getCurrentHighestVersion( ++ fixedPackages, ++ packagesByName ++ ); // Finally, we update the packages so all of them are on the highest version + + for (let pkgName of fixedPackages) { +- if (shouldSkipPackage.shouldSkipPackage(packagesByName.get(pkgName), { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })) { ++ if ( ++ shouldSkipPackage.shouldSkipPackage(packagesByName.get(pkgName), { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) { + continue; + } + +@@ -374,7 +427,7 @@ function matchFixedConstraint(releases, packagesByName, config) { + name: pkgName, + type: highestReleaseType, + oldVersion: highestVersion, +- changesets: [] ++ changesets: [], + }); + continue; + } +@@ -396,7 +449,8 @@ function matchFixedConstraint(releases, packagesByName, config) { + + function getPreVersion(version) { + let parsed = semverParse__default["default"](version); +- let preVersion = parsed.prerelease[1] === undefined ? -1 : parsed.prerelease[1]; ++ let preVersion = ++ parsed.prerelease[1] === undefined ? -1 : parsed.prerelease[1]; + + if (typeof preVersion !== "number") { + throw new errors.InternalError("preVersion is not a number"); +@@ -412,18 +466,25 @@ function getSnapshotSuffix(template, snapshotParameters) { + commit: snapshotParameters.commit, + tag: snapshotParameters.tag, + timestamp: snapshotRefDate.getTime().toString(), +- datetime: snapshotRefDate.toISOString().replace(/\.\d{3}Z$/, "").replace(/[^\d]/g, "") ++ datetime: snapshotRefDate ++ .toISOString() ++ .replace(/\.\d{3}Z$/, "") ++ .replace(/[^\d]/g, ""), + }; // We need a special handling because we need to handle a case where `--snapshot` is used without any template, + // and the resulting version needs to be composed without a tag. + + if (!template) { +- return [placeholderValues.tag, placeholderValues.datetime].filter(Boolean).join("-"); ++ return [placeholderValues.tag, placeholderValues.datetime] ++ .filter(Boolean) ++ .join("-"); + } + + const placeholders = Object.keys(placeholderValues); + + if (!template.includes(`{tag}`) && placeholderValues.tag !== undefined) { +- throw new Error(`Failed to compose snapshot version: "{tag}" placeholder is missing, but the snapshot parameter is defined (value: '${placeholderValues.tag}')`); ++ throw new Error( ++ `Failed to compose snapshot version: "{tag}" placeholder is missing, but the snapshot parameter is defined (value: '${placeholderValues.tag}')` ++ ); + } + + return placeholders.reduce((prev, key) => { +@@ -431,7 +492,9 @@ function getSnapshotSuffix(template, snapshotParameters) { + const value = placeholderValues[key]; + + if (value === undefined) { +- throw new Error(`Failed to compose snapshot version: "{${key}}" placeholder is used without having a value defined!`); ++ throw new Error( ++ `Failed to compose snapshot version: "{${key}}" placeholder is used without having a value defined!` ++ ); + } + + return value; +@@ -439,7 +502,12 @@ function getSnapshotSuffix(template, snapshotParameters) { + }, template); + } + +-function getSnapshotVersion(release, preInfo, useCalculatedVersion, snapshotSuffix) { ++function getSnapshotVersion( ++ release, ++ preInfo, ++ useCalculatedVersion, ++ snapshotSuffix ++) { + if (release.type === "none") { + return release.oldVersion; + } +@@ -453,8 +521,9 @@ function getSnapshotVersion(release, preInfo, useCalculatedVersion, snapshotSuff + * You can set `snapshot.useCalculatedVersion` flag to true to use calculated versions if you don't care about the above problem. + */ + +- +- const baseVersion = useCalculatedVersion ? incrementVersion(release, preInfo) : `0.0.0`; ++ const baseVersion = useCalculatedVersion ++ ? incrementVersion(release, preInfo) ++ : `0.0.0`; + return `${baseVersion}-${snapshotSuffix}`; + } + +@@ -466,33 +535,67 @@ function getNewVersion(release, preInfo) { + return incrementVersion(release, preInfo); + } + +-function assembleReleasePlan(changesets, packages, config, // intentionally not using an optional parameter here so the result of `readPreState` has to be passed in here +-preState, // snapshot: undefined -> not using snaphot +-// snapshot: { tag: undefined } -> --snapshot (empty tag) +-// snapshot: { tag: "canary" } -> --snapshot canary +-snapshot) { ++function assembleReleasePlan( ++ changesets, ++ packages, ++ config, // intentionally not using an optional parameter here so the result of `readPreState` has to be passed in here ++ preState, // snapshot: undefined -> not using snaphot ++ // snapshot: { tag: undefined } -> --snapshot (empty tag) ++ // snapshot: { tag: "canary" } -> --snapshot canary ++ snapshot ++) { + // TODO: remove `refined*` in the next major version of this package + // just use `config` and `snapshot` parameters directly, typed as: `config: Config, snapshot?: SnapshotReleaseParameters` +- const refinedConfig = config.snapshot ? config : _objectSpread(_objectSpread({}, config), {}, { +- snapshot: { +- prereleaseTemplate: null, +- useCalculatedVersion: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.useCalculatedVersionForSnapshots +- } +- }); +- const refinedSnapshot = typeof snapshot === "string" ? { +- tag: snapshot +- } : typeof snapshot === "boolean" ? { +- tag: undefined +- } : snapshot; +- let packagesByName = new Map(packages.packages.map(x => [x.packageJson.name, x])); +- const relevantChangesets = getRelevantChangesets(changesets, packagesByName, refinedConfig, preState); +- const preInfo = getPreInfo(changesets, packagesByName, refinedConfig, preState); // releases is, at this point a list of all packages we are going to releases, ++ const refinedConfig = config.snapshot ++ ? config ++ : _objectSpread( ++ _objectSpread({}, config), ++ {}, ++ { ++ snapshot: { ++ prereleaseTemplate: null, ++ useCalculatedVersion: ++ config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH ++ .useCalculatedVersionForSnapshots, ++ }, ++ } ++ ); ++ const refinedSnapshot = ++ typeof snapshot === "string" ++ ? { ++ tag: snapshot, ++ } ++ : typeof snapshot === "boolean" ++ ? { ++ tag: undefined, ++ } ++ : snapshot; ++ let packagesByName = new Map( ++ packages.packages.map((x) => [x.packageJson.name, x]) ++ ); ++ const relevantChangesets = getRelevantChangesets( ++ changesets, ++ packagesByName, ++ refinedConfig, ++ preState ++ ); ++ const preInfo = getPreInfo( ++ changesets, ++ packagesByName, ++ refinedConfig, ++ preState ++ ); // releases is, at this point a list of all packages we are going to releases, + // flattened down to one release per package, having a reference back to their + // changesets, and with a calculated new versions + +- let releases = flattenReleases(relevantChangesets, packagesByName, refinedConfig); ++ let releases = flattenReleases( ++ relevantChangesets, ++ packagesByName, ++ refinedConfig ++ ); + let dependencyGraph = getDependentsGraph.getDependentsGraph(packages, { +- bumpVersionsWithWorkspaceProtocolOnly: refinedConfig.bumpVersionsWithWorkspaceProtocolOnly ++ bumpVersionsWithWorkspaceProtocolOnly: ++ refinedConfig.bumpVersionsWithWorkspaceProtocolOnly, + }); + let releasesValidated = false; + +@@ -503,15 +606,27 @@ snapshot) { + packagesByName, + dependencyGraph, + preInfo, +- config: refinedConfig ++ config: refinedConfig, + }); // `releases` might get mutated here + +- let fixedConstraintUpdated = matchFixedConstraint(releases, packagesByName, refinedConfig); +- let linksUpdated = applyLinks(releases, packagesByName, refinedConfig.linked); +- releasesValidated = !linksUpdated && !dependentAdded && !fixedConstraintUpdated; ++ let fixedConstraintUpdated = matchFixedConstraint( ++ releases, ++ packagesByName, ++ refinedConfig ++ ); ++ let linksUpdated = applyLinks( ++ releases, ++ packagesByName, ++ refinedConfig.linked ++ ); ++ releasesValidated = ++ !linksUpdated && !dependentAdded && !fixedConstraintUpdated; + } + +- if ((preInfo === null || preInfo === void 0 ? void 0 : preInfo.state.mode) === "exit") { ++ if ( ++ (preInfo === null || preInfo === void 0 ? void 0 : preInfo.state.mode) === ++ "exit" ++ ) { + for (let pkg of packages.packages) { + // If a package had a prerelease, but didn't trigger a version bump in the regular release, + // we want to give it a patch release. +@@ -524,28 +639,46 @@ snapshot) { + name: pkg.packageJson.name, + type: "patch", + oldVersion: pkg.packageJson.version, +- changesets: [] ++ changesets: [], + }); +- } else if (existingRelease.type === "none" && !shouldSkipPackage.shouldSkipPackage(pkg, { +- ignore: refinedConfig.ignore, +- allowPrivatePackages: refinedConfig.privatePackages.version +- })) { ++ } else if ( ++ existingRelease.type === "none" && ++ !shouldSkipPackage.shouldSkipPackage(pkg, { ++ ignore: refinedConfig.ignore, ++ allowPrivatePackages: refinedConfig.privatePackages.version, ++ }) ++ ) { + existingRelease.type = "patch"; + } + } + } + } // Caching the snapshot version here and use this if it is snapshot release + +- +- const snapshotSuffix = refinedSnapshot && getSnapshotSuffix(refinedConfig.snapshot.prereleaseTemplate, refinedSnapshot); ++ const snapshotSuffix = ++ refinedSnapshot && ++ getSnapshotSuffix( ++ refinedConfig.snapshot.prereleaseTemplate, ++ refinedSnapshot ++ ); + return { + changesets: relevantChangesets, +- releases: [...releases.values()].map(incompleteRelease => { +- return _objectSpread(_objectSpread({}, incompleteRelease), {}, { +- newVersion: snapshotSuffix ? getSnapshotVersion(incompleteRelease, preInfo, refinedConfig.snapshot.useCalculatedVersion, snapshotSuffix) : getNewVersion(incompleteRelease, preInfo) +- }); ++ releases: [...releases.values()].map((incompleteRelease) => { ++ return _objectSpread( ++ _objectSpread({}, incompleteRelease), ++ {}, ++ { ++ newVersion: snapshotSuffix ++ ? getSnapshotVersion( ++ incompleteRelease, ++ preInfo, ++ refinedConfig.snapshot.useCalculatedVersion, ++ snapshotSuffix ++ ) ++ : getNewVersion(incompleteRelease, preInfo), ++ } ++ ); + }), +- preState: preInfo === null || preInfo === void 0 ? void 0 : preInfo.state ++ preState: preInfo === null || preInfo === void 0 ? void 0 : preInfo.state, + }; + } + +@@ -557,10 +690,12 @@ function getRelevantChangesets(changesets, packagesByName, config, preState) { + const notSkippedPackages = []; + + for (const release of changeset.releases) { +- if (shouldSkipPackage.shouldSkipPackage(packagesByName.get(release.name), { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })) { ++ if ( ++ shouldSkipPackage.shouldSkipPackage(packagesByName.get(release.name), { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) { + skippedPackages.push(release.name); + } else { + notSkippedPackages.push(release.name); +@@ -568,13 +703,20 @@ function getRelevantChangesets(changesets, packagesByName, config, preState) { + } + + if (skippedPackages.length > 0 && notSkippedPackages.length > 0) { +- throw new Error(`Found mixed changeset ${changeset.id}\n` + `Found ignored packages: ${skippedPackages.join(" ")}\n` + `Found not ignored packages: ${notSkippedPackages.join(" ")}\n` + "Mixed changesets that contain both ignored and not ignored packages are not allowed"); ++ throw new Error( ++ `Found mixed changeset ${changeset.id}\n` + ++ `Found ignored packages: ${skippedPackages.join(" ")}\n` + ++ `Found not ignored packages: ${notSkippedPackages.join(" ")}\n` + ++ "Mixed changesets that contain both ignored and not ignored packages are not allowed" ++ ); + } + } + + if (preState && preState.mode !== "exit") { + let usedChangesetIds = new Set(preState.changesets); +- return changesets.filter(changeset => !usedChangesetIds.has(changeset.id)); ++ return changesets.filter( ++ (changeset) => !usedChangesetIds.has(changeset.id) ++ ); + } + + return changesets; +@@ -584,7 +726,10 @@ function getHighestPreVersion(packageGroup, packagesByName) { + let highestPreVersion = 0; + + for (let pkg of packageGroup) { +- highestPreVersion = Math.max(getPreVersion(packagesByName.get(pkg).packageJson.version), highestPreVersion); ++ highestPreVersion = Math.max( ++ getPreVersion(packagesByName.get(pkg).packageJson.version), ++ highestPreVersion ++ ); + } + + return highestPreVersion; +@@ -595,23 +740,30 @@ function getPreInfo(changesets, packagesByName, config, preState) { + return; + } + +- let updatedPreState = _objectSpread(_objectSpread({}, preState), {}, { +- changesets: changesets.map(changeset => changeset.id), +- initialVersions: _objectSpread({}, preState.initialVersions) +- }); ++ let updatedPreState = _objectSpread( ++ _objectSpread({}, preState), ++ {}, ++ { ++ changesets: changesets.map((changeset) => changeset.id), ++ initialVersions: _objectSpread({}, preState.initialVersions), ++ } ++ ); + + for (const [, pkg] of packagesByName) { + if (updatedPreState.initialVersions[pkg.packageJson.name] === undefined) { +- updatedPreState.initialVersions[pkg.packageJson.name] = pkg.packageJson.version; ++ updatedPreState.initialVersions[pkg.packageJson.name] = ++ pkg.packageJson.version; + } + } // Populate preVersion + // preVersion is the map between package name and its next pre version number. + +- + let preVersions = new Map(); + + for (const [, pkg] of packagesByName) { +- preVersions.set(pkg.packageJson.name, getPreVersion(pkg.packageJson.version)); ++ preVersions.set( ++ pkg.packageJson.name, ++ getPreVersion(pkg.packageJson.version) ++ ); + } + + for (let fixedGroup of config.fixed) { +@@ -632,7 +784,7 @@ function getPreInfo(changesets, packagesByName, config, preState) { + + return { + state: updatedPreState, +- preVersions ++ preVersions, + }; + } + +diff --git a/dist/changesets-assemble-release-plan.esm.js b/dist/changesets-assemble-release-plan.esm.js +index f6583cf3f639e1fe4df764a015689dea74127236..a8273d853108d0f72118f9893a4ac7dff0cccb1d 100644 +--- a/dist/changesets-assemble-release-plan.esm.js ++++ b/dist/changesets-assemble-release-plan.esm.js +@@ -1,15 +1,17 @@ +-import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2'; +-import { InternalError } from '@changesets/errors'; +-import { getDependentsGraph } from '@changesets/get-dependents-graph'; +-import { shouldSkipPackage } from '@changesets/should-skip-package'; +-import semverParse from 'semver/functions/parse'; +-import semverGt from 'semver/functions/gt'; +-import semverSatisfies from 'semver/functions/satisfies'; +-import semverInc from 'semver/functions/inc'; ++import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2"; ++import { InternalError } from "@changesets/errors"; ++import { getDependentsGraph } from "@changesets/get-dependents-graph"; ++import { shouldSkipPackage } from "@changesets/should-skip-package"; ++import semverParse from "semver/functions/parse"; ++import semverGt from "semver/functions/gt"; ++import semverSatisfies from "semver/functions/satisfies"; ++import semverInc from "semver/functions/inc"; + + function getHighestReleaseType(releases) { + if (releases.length === 0) { +- throw new Error(`Large internal Changesets error when calculating highest release type in the set of releases. Please contact the maintainers`); ++ throw new Error( ++ `Large internal Changesets error when calculating highest release type in the set of releases. Please contact the maintainers` ++ ); + } + + let highestReleaseType = "none"; +@@ -41,11 +43,16 @@ function getCurrentHighestVersion(packageGroup, packagesByName) { + let pkg = packagesByName.get(pkgName); + + if (!pkg) { +- console.error(`FATAL ERROR IN CHANGESETS! We were unable to version for package group: ${pkgName} in package group: ${packageGroup.toString()}`); ++ console.error( ++ `FATAL ERROR IN CHANGESETS! We were unable to version for package group: ${pkgName} in package group: ${packageGroup.toString()}` ++ ); + throw new Error(`fatal: could not resolve linked packages`); + } + +- if (highestVersion === undefined || semverGt(pkg.packageJson.version, highestVersion)) { ++ if ( ++ highestVersion === undefined || ++ semverGt(pkg.packageJson.version, highestVersion) ++ ) { + highestVersion = pkg.packageJson.version; + } + } +@@ -71,12 +78,18 @@ function applyLinks(releases, packagesByName, linked) { + + for (let linkedPackages of linked) { + // First we filter down to all the relevant releases for one set of linked packages +- let releasingLinkedPackages = [...releases.values()].filter(release => linkedPackages.includes(release.name) && release.type !== "none"); // If we proceed any further we do extra work with calculating highestVersion for things that might ++ let releasingLinkedPackages = [...releases.values()].filter( ++ (release) => ++ linkedPackages.includes(release.name) && release.type !== "none" ++ ); // If we proceed any further we do extra work with calculating highestVersion for things that might + // not need one, as they only have workspace based packages + + if (releasingLinkedPackages.length === 0) continue; + let highestReleaseType = getHighestReleaseType(releasingLinkedPackages); +- let highestVersion = getCurrentHighestVersion(linkedPackages, packagesByName); // Finally, we update the packages so all of them are on the highest version ++ let highestVersion = getCurrentHighestVersion( ++ linkedPackages, ++ packagesByName ++ ); // Finally, we update the packages so all of them are on the highest version + + for (let linkedPackage of releasingLinkedPackages) { + if (linkedPackage.type !== highestReleaseType) { +@@ -105,11 +118,12 @@ function incrementVersion(release, preInfo) { + let preVersion = preInfo.preVersions.get(release.name); + + if (preVersion === undefined) { +- throw new InternalError(`preVersion for ${release.name} does not exist when preState is defined`); ++ throw new InternalError( ++ `preVersion for ${release.name} does not exist when preState is defined` ++ ); + } // why are we adding this ourselves rather than passing 'pre' + versionType to semver.inc? + // because semver.inc with prereleases is confusing and this seems easier + +- + version += `-${preInfo.state.tag}.${preVersion}`; + } + +@@ -133,7 +147,7 @@ function determineDependents({ + packagesByName, + dependencyGraph, + preInfo, +- config ++ config, + }) { + let updated = false; // NOTE this is intended to be called recursively + +@@ -147,96 +161,101 @@ function determineDependents({ + const pkgDependents = dependencyGraph.get(nextRelease.name); + + if (!pkgDependents) { +- throw new Error(`Error in determining dependents - could not find package in repository: ${nextRelease.name}`); ++ throw new Error( ++ `Error in determining dependents - could not find package in repository: ${nextRelease.name}` ++ ); + } + +- pkgDependents.map(dependent => { +- let type; +- const dependentPackage = packagesByName.get(dependent); +- if (!dependentPackage) throw new Error("Dependency map is incorrect"); +- +- if (shouldSkipPackage(dependentPackage, { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })) { +- type = "none"; +- } else { +- const dependencyVersionRanges = getDependencyVersionRanges(dependentPackage.packageJson, nextRelease); +- +- for (const { +- depType, +- versionRange +- } of dependencyVersionRanges) { +- if (nextRelease.type === "none") { +- continue; +- } else if (shouldBumpMajor({ +- dependent, +- depType, +- versionRange, +- releases, +- nextRelease, +- preInfo, +- onlyUpdatePeerDependentsWhenOutOfRange: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.onlyUpdatePeerDependentsWhenOutOfRange +- })) { +- type = "major"; +- } else if ((!releases.has(dependent) || releases.get(dependent).type === "none") && (config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.updateInternalDependents === "always" || !semverSatisfies(incrementVersion(nextRelease, preInfo), versionRange))) { +- switch (depType) { +- case "dependencies": +- case "optionalDependencies": +- case "peerDependencies": +- if (type !== "major" && type !== "minor") { +- type = "patch"; +- } ++ pkgDependents ++ .map((dependent) => { ++ let type; ++ const dependentPackage = packagesByName.get(dependent); ++ if (!dependentPackage) throw new Error("Dependency map is incorrect"); ++ ++ if ( ++ shouldSkipPackage(dependentPackage, { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) { ++ type = "none"; ++ } else { ++ const dependencyVersionRanges = getDependencyVersionRanges( ++ dependentPackage.packageJson, ++ nextRelease ++ ); ++ ++ for (const { depType, versionRange } of dependencyVersionRanges) { ++ if (nextRelease.type === "none") { ++ continue; ++ } else if ( ++ (!releases.has(dependent) || ++ releases.get(dependent).type === "none") && ++ (config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH ++ .updateInternalDependents === "always" || ++ !semverSatisfies( ++ incrementVersion(nextRelease, preInfo), ++ versionRange ++ )) ++ ) { ++ switch (depType) { ++ case "dependencies": ++ case "optionalDependencies": ++ case "peerDependencies": ++ if (type !== "major" && type !== "minor") { ++ type = "patch"; ++ } + +- break; ++ break; + +- case "devDependencies": +- { ++ case "devDependencies": { + // We don't need a version bump if the package is only in the devDependencies of the dependent package +- if (type !== "major" && type !== "minor" && type !== "patch") { ++ if ( ++ type !== "major" && ++ type !== "minor" && ++ type !== "patch" ++ ) { + type = "none"; + } + } ++ } + } + } + } +- } + +- if (releases.has(dependent) && releases.get(dependent).type === type) { +- type = undefined; +- } ++ if (releases.has(dependent) && releases.get(dependent).type === type) { ++ type = undefined; ++ } + +- return { +- name: dependent, +- type, +- pkgJSON: dependentPackage.packageJson +- }; +- }).filter(dependentItem => !!dependentItem.type).forEach(({ +- name, +- type, +- pkgJSON +- }) => { +- // At this point, we know if we are making a change +- updated = true; +- const existing = releases.get(name); // For things that are being given a major bump, we check if we have already +- // added them here. If we have, we update the existing item instead of pushing it on to search. +- // It is safe to not add it to pkgsToSearch because it should have already been searched at the +- // largest possible bump type. +- +- if (existing && type === "major" && existing.type !== "major") { +- existing.type = "major"; +- pkgsToSearch.push(existing); +- } else { +- let newDependent = { +- name, ++ return { ++ name: dependent, + type, +- oldVersion: pkgJSON.version, +- changesets: [] ++ pkgJSON: dependentPackage.packageJson, + }; +- pkgsToSearch.push(newDependent); +- releases.set(name, newDependent); +- } +- }); ++ }) ++ .filter((dependentItem) => !!dependentItem.type) ++ .forEach(({ name, type, pkgJSON }) => { ++ // At this point, we know if we are making a change ++ updated = true; ++ const existing = releases.get(name); // For things that are being given a major bump, we check if we have already ++ // added them here. If we have, we update the existing item instead of pushing it on to search. ++ // It is safe to not add it to pkgsToSearch because it should have already been searched at the ++ // largest possible bump type. ++ ++ if (existing && type === "major" && existing.type !== "major") { ++ existing.type = "major"; ++ pkgsToSearch.push(existing); ++ } else { ++ let newDependent = { ++ name, ++ type, ++ oldVersion: pkgJSON.version, ++ changesets: [], ++ }; ++ pkgsToSearch.push(newDependent); ++ releases.set(name, newDependent); ++ } ++ }); + } + + return updated; +@@ -248,27 +267,38 @@ function determineDependents({ + */ + + function getDependencyVersionRanges(dependentPkgJSON, dependencyRelease) { +- const DEPENDENCY_TYPES = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]; ++ const DEPENDENCY_TYPES = [ ++ "dependencies", ++ "devDependencies", ++ "peerDependencies", ++ "optionalDependencies", ++ ]; + const dependencyVersionRanges = []; + + for (const type of DEPENDENCY_TYPES) { + var _dependentPkgJSON$typ; + +- const versionRange = (_dependentPkgJSON$typ = dependentPkgJSON[type]) === null || _dependentPkgJSON$typ === void 0 ? void 0 : _dependentPkgJSON$typ[dependencyRelease.name]; ++ const versionRange = ++ (_dependentPkgJSON$typ = dependentPkgJSON[type]) === null || ++ _dependentPkgJSON$typ === void 0 ++ ? void 0 ++ : _dependentPkgJSON$typ[dependencyRelease.name]; + if (!versionRange) continue; + + if (versionRange.startsWith("workspace:")) { + dependencyVersionRanges.push({ + depType: type, +- versionRange: // intentionally keep other workspace ranges untouched +- // this has to be fixed but this should only be done when adding appropriate tests +- versionRange === "workspace:*" ? // workspace:* actually means the current exact version, and not a wildcard similar to a reguler * range +- dependencyRelease.oldVersion : versionRange.replace(/^workspace:/, "") ++ // intentionally keep other workspace ranges untouched ++ versionRange: ++ // this has to be fixed but this should only be done when adding appropriate tests ++ versionRange === "workspace:*" // workspace:* actually means the current exact version, and not a wildcard similar to a reguler * range ++ ? dependencyRelease.oldVersion ++ : versionRange.replace(/^workspace:/, ""), + }); + } else { + dependencyVersionRanges.push({ + depType: type, +- versionRange ++ versionRange, + }); + } + } +@@ -283,57 +313,67 @@ function shouldBumpMajor({ + releases, + nextRelease, + preInfo, +- onlyUpdatePeerDependentsWhenOutOfRange ++ onlyUpdatePeerDependentsWhenOutOfRange, + }) { + // we check if it is a peerDependency because if it is, our dependent bump type might need to be major. +- return depType === "peerDependencies" && nextRelease.type !== "none" && nextRelease.type !== "patch" && ( // 1. If onlyUpdatePeerDependentsWhenOutOfRange set to true, bump major if the version is leaving the range. +- // 2. If onlyUpdatePeerDependentsWhenOutOfRange set to false, bump major regardless whether or not the version is leaving the range. +- !onlyUpdatePeerDependentsWhenOutOfRange || !semverSatisfies(incrementVersion(nextRelease, preInfo), versionRange)) && ( // bump major only if the dependent doesn't already has a major release. +- !releases.has(dependent) || releases.has(dependent) && releases.get(dependent).type !== "major"); ++ return ( ++ depType === "peerDependencies" && ++ nextRelease.type !== "none" && ++ nextRelease.type !== "patch" && // 1. If onlyUpdatePeerDependentsWhenOutOfRange set to true, bump major if the version is leaving the range. ++ // 2. If onlyUpdatePeerDependentsWhenOutOfRange set to false, bump major regardless whether or not the version is leaving the range. ++ (!onlyUpdatePeerDependentsWhenOutOfRange || ++ !semverSatisfies(incrementVersion(nextRelease, preInfo), versionRange)) && // bump major only if the dependent doesn't already has a major release. ++ (!releases.has(dependent) || ++ (releases.has(dependent) && releases.get(dependent).type !== "major")) ++ ); + } + + // This function takes in changesets and returns one release per + function flattenReleases(changesets, packagesByName, config) { + let releases = new Map(); +- changesets.forEach(changeset => { ++ changesets.forEach((changeset) => { + changeset.releases // Filter out skipped 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` +- .filter(({ +- name +- }) => !shouldSkipPackage(packagesByName.get(name), { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })).forEach(({ +- name, +- type +- }) => { +- let release = releases.get(name); +- let pkg = packagesByName.get(name); +- +- if (!pkg) { +- throw new Error(`"${changeset.id}" changeset mentions a release for a package "${name}" but such a package could not be found.`); +- } +- +- if (!release) { +- release = { +- name, +- type, +- oldVersion: pkg.packageJson.version, +- changesets: [changeset.id] +- }; +- } else { +- if (type === "major" || (release.type === "patch" || release.type === "none") && (type === "minor" || type === "patch")) { +- release.type = type; +- } // Check whether the bumpType will change +- // If the bumpType has changed recalc newVersion +- // push new changeset to releases +- ++ // If their dependencies need updates, they will be added to releases by `determineDependents()` with release type `none` ++ .filter( ++ ({ name }) => ++ !shouldSkipPackage(packagesByName.get(name), { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) ++ .forEach(({ name, type }) => { ++ let release = releases.get(name); ++ let pkg = packagesByName.get(name); ++ ++ if (!pkg) { ++ throw new Error( ++ `"${changeset.id}" changeset mentions a release for a package "${name}" but such a package could not be found.` ++ ); ++ } + +- release.changesets.push(changeset.id); +- } ++ if (!release) { ++ release = { ++ name, ++ type, ++ oldVersion: pkg.packageJson.version, ++ changesets: [changeset.id], ++ }; ++ } else { ++ if ( ++ type === "major" || ++ ((release.type === "patch" || release.type === "none") && ++ (type === "minor" || type === "patch")) ++ ) { ++ release.type = type; ++ } // Check whether the bumpType will change ++ // If the bumpType has changed recalc newVersion ++ // push new changeset to releases ++ ++ release.changesets.push(changeset.id); ++ } + +- releases.set(name, release); +- }); ++ releases.set(name, release); ++ }); + }); + return releases; + } +@@ -342,16 +382,24 @@ function matchFixedConstraint(releases, packagesByName, config) { + let updated = false; + + for (let fixedPackages of config.fixed) { +- let releasingFixedPackages = [...releases.values()].filter(release => fixedPackages.includes(release.name) && release.type !== "none"); ++ let releasingFixedPackages = [...releases.values()].filter( ++ (release) => ++ fixedPackages.includes(release.name) && release.type !== "none" ++ ); + if (releasingFixedPackages.length === 0) continue; + let highestReleaseType = getHighestReleaseType(releasingFixedPackages); +- let highestVersion = getCurrentHighestVersion(fixedPackages, packagesByName); // Finally, we update the packages so all of them are on the highest version ++ let highestVersion = getCurrentHighestVersion( ++ fixedPackages, ++ packagesByName ++ ); // Finally, we update the packages so all of them are on the highest version + + for (let pkgName of fixedPackages) { +- if (shouldSkipPackage(packagesByName.get(pkgName), { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })) { ++ if ( ++ shouldSkipPackage(packagesByName.get(pkgName), { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) { + continue; + } + +@@ -363,7 +411,7 @@ function matchFixedConstraint(releases, packagesByName, config) { + name: pkgName, + type: highestReleaseType, + oldVersion: highestVersion, +- changesets: [] ++ changesets: [], + }); + continue; + } +@@ -385,7 +433,8 @@ function matchFixedConstraint(releases, packagesByName, config) { + + function getPreVersion(version) { + let parsed = semverParse(version); +- let preVersion = parsed.prerelease[1] === undefined ? -1 : parsed.prerelease[1]; ++ let preVersion = ++ parsed.prerelease[1] === undefined ? -1 : parsed.prerelease[1]; + + if (typeof preVersion !== "number") { + throw new InternalError("preVersion is not a number"); +@@ -401,18 +450,25 @@ function getSnapshotSuffix(template, snapshotParameters) { + commit: snapshotParameters.commit, + tag: snapshotParameters.tag, + timestamp: snapshotRefDate.getTime().toString(), +- datetime: snapshotRefDate.toISOString().replace(/\.\d{3}Z$/, "").replace(/[^\d]/g, "") ++ datetime: snapshotRefDate ++ .toISOString() ++ .replace(/\.\d{3}Z$/, "") ++ .replace(/[^\d]/g, ""), + }; // We need a special handling because we need to handle a case where `--snapshot` is used without any template, + // and the resulting version needs to be composed without a tag. + + if (!template) { +- return [placeholderValues.tag, placeholderValues.datetime].filter(Boolean).join("-"); ++ return [placeholderValues.tag, placeholderValues.datetime] ++ .filter(Boolean) ++ .join("-"); + } + + const placeholders = Object.keys(placeholderValues); + + if (!template.includes(`{tag}`) && placeholderValues.tag !== undefined) { +- throw new Error(`Failed to compose snapshot version: "{tag}" placeholder is missing, but the snapshot parameter is defined (value: '${placeholderValues.tag}')`); ++ throw new Error( ++ `Failed to compose snapshot version: "{tag}" placeholder is missing, but the snapshot parameter is defined (value: '${placeholderValues.tag}')` ++ ); + } + + return placeholders.reduce((prev, key) => { +@@ -420,7 +476,9 @@ function getSnapshotSuffix(template, snapshotParameters) { + const value = placeholderValues[key]; + + if (value === undefined) { +- throw new Error(`Failed to compose snapshot version: "{${key}}" placeholder is used without having a value defined!`); ++ throw new Error( ++ `Failed to compose snapshot version: "{${key}}" placeholder is used without having a value defined!` ++ ); + } + + return value; +@@ -428,7 +486,12 @@ function getSnapshotSuffix(template, snapshotParameters) { + }, template); + } + +-function getSnapshotVersion(release, preInfo, useCalculatedVersion, snapshotSuffix) { ++function getSnapshotVersion( ++ release, ++ preInfo, ++ useCalculatedVersion, ++ snapshotSuffix ++) { + if (release.type === "none") { + return release.oldVersion; + } +@@ -442,8 +505,9 @@ function getSnapshotVersion(release, preInfo, useCalculatedVersion, snapshotSuff + * You can set `snapshot.useCalculatedVersion` flag to true to use calculated versions if you don't care about the above problem. + */ + +- +- const baseVersion = useCalculatedVersion ? incrementVersion(release, preInfo) : `0.0.0`; ++ const baseVersion = useCalculatedVersion ++ ? incrementVersion(release, preInfo) ++ : `0.0.0`; + return `${baseVersion}-${snapshotSuffix}`; + } + +@@ -455,33 +519,67 @@ function getNewVersion(release, preInfo) { + return incrementVersion(release, preInfo); + } + +-function assembleReleasePlan(changesets, packages, config, // intentionally not using an optional parameter here so the result of `readPreState` has to be passed in here +-preState, // snapshot: undefined -> not using snaphot +-// snapshot: { tag: undefined } -> --snapshot (empty tag) +-// snapshot: { tag: "canary" } -> --snapshot canary +-snapshot) { ++function assembleReleasePlan( ++ changesets, ++ packages, ++ config, // intentionally not using an optional parameter here so the result of `readPreState` has to be passed in here ++ preState, // snapshot: undefined -> not using snaphot ++ // snapshot: { tag: undefined } -> --snapshot (empty tag) ++ // snapshot: { tag: "canary" } -> --snapshot canary ++ snapshot ++) { + // TODO: remove `refined*` in the next major version of this package + // just use `config` and `snapshot` parameters directly, typed as: `config: Config, snapshot?: SnapshotReleaseParameters` +- const refinedConfig = config.snapshot ? config : _objectSpread(_objectSpread({}, config), {}, { +- snapshot: { +- prereleaseTemplate: null, +- useCalculatedVersion: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.useCalculatedVersionForSnapshots +- } +- }); +- const refinedSnapshot = typeof snapshot === "string" ? { +- tag: snapshot +- } : typeof snapshot === "boolean" ? { +- tag: undefined +- } : snapshot; +- let packagesByName = new Map(packages.packages.map(x => [x.packageJson.name, x])); +- const relevantChangesets = getRelevantChangesets(changesets, packagesByName, refinedConfig, preState); +- const preInfo = getPreInfo(changesets, packagesByName, refinedConfig, preState); // releases is, at this point a list of all packages we are going to releases, ++ const refinedConfig = config.snapshot ++ ? config ++ : _objectSpread( ++ _objectSpread({}, config), ++ {}, ++ { ++ snapshot: { ++ prereleaseTemplate: null, ++ useCalculatedVersion: ++ config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH ++ .useCalculatedVersionForSnapshots, ++ }, ++ } ++ ); ++ const refinedSnapshot = ++ typeof snapshot === "string" ++ ? { ++ tag: snapshot, ++ } ++ : typeof snapshot === "boolean" ++ ? { ++ tag: undefined, ++ } ++ : snapshot; ++ let packagesByName = new Map( ++ packages.packages.map((x) => [x.packageJson.name, x]) ++ ); ++ const relevantChangesets = getRelevantChangesets( ++ changesets, ++ packagesByName, ++ refinedConfig, ++ preState ++ ); ++ const preInfo = getPreInfo( ++ changesets, ++ packagesByName, ++ refinedConfig, ++ preState ++ ); // releases is, at this point a list of all packages we are going to releases, + // flattened down to one release per package, having a reference back to their + // changesets, and with a calculated new versions + +- let releases = flattenReleases(relevantChangesets, packagesByName, refinedConfig); ++ let releases = flattenReleases( ++ relevantChangesets, ++ packagesByName, ++ refinedConfig ++ ); + let dependencyGraph = getDependentsGraph(packages, { +- bumpVersionsWithWorkspaceProtocolOnly: refinedConfig.bumpVersionsWithWorkspaceProtocolOnly ++ bumpVersionsWithWorkspaceProtocolOnly: ++ refinedConfig.bumpVersionsWithWorkspaceProtocolOnly, + }); + let releasesValidated = false; + +@@ -492,15 +590,27 @@ snapshot) { + packagesByName, + dependencyGraph, + preInfo, +- config: refinedConfig ++ config: refinedConfig, + }); // `releases` might get mutated here + +- let fixedConstraintUpdated = matchFixedConstraint(releases, packagesByName, refinedConfig); +- let linksUpdated = applyLinks(releases, packagesByName, refinedConfig.linked); +- releasesValidated = !linksUpdated && !dependentAdded && !fixedConstraintUpdated; ++ let fixedConstraintUpdated = matchFixedConstraint( ++ releases, ++ packagesByName, ++ refinedConfig ++ ); ++ let linksUpdated = applyLinks( ++ releases, ++ packagesByName, ++ refinedConfig.linked ++ ); ++ releasesValidated = ++ !linksUpdated && !dependentAdded && !fixedConstraintUpdated; + } + +- if ((preInfo === null || preInfo === void 0 ? void 0 : preInfo.state.mode) === "exit") { ++ if ( ++ (preInfo === null || preInfo === void 0 ? void 0 : preInfo.state.mode) === ++ "exit" ++ ) { + for (let pkg of packages.packages) { + // If a package had a prerelease, but didn't trigger a version bump in the regular release, + // we want to give it a patch release. +@@ -513,28 +623,46 @@ snapshot) { + name: pkg.packageJson.name, + type: "patch", + oldVersion: pkg.packageJson.version, +- changesets: [] ++ changesets: [], + }); +- } else if (existingRelease.type === "none" && !shouldSkipPackage(pkg, { +- ignore: refinedConfig.ignore, +- allowPrivatePackages: refinedConfig.privatePackages.version +- })) { ++ } else if ( ++ existingRelease.type === "none" && ++ !shouldSkipPackage(pkg, { ++ ignore: refinedConfig.ignore, ++ allowPrivatePackages: refinedConfig.privatePackages.version, ++ }) ++ ) { + existingRelease.type = "patch"; + } + } + } + } // Caching the snapshot version here and use this if it is snapshot release + +- +- const snapshotSuffix = refinedSnapshot && getSnapshotSuffix(refinedConfig.snapshot.prereleaseTemplate, refinedSnapshot); ++ const snapshotSuffix = ++ refinedSnapshot && ++ getSnapshotSuffix( ++ refinedConfig.snapshot.prereleaseTemplate, ++ refinedSnapshot ++ ); + return { + changesets: relevantChangesets, +- releases: [...releases.values()].map(incompleteRelease => { +- return _objectSpread(_objectSpread({}, incompleteRelease), {}, { +- newVersion: snapshotSuffix ? getSnapshotVersion(incompleteRelease, preInfo, refinedConfig.snapshot.useCalculatedVersion, snapshotSuffix) : getNewVersion(incompleteRelease, preInfo) +- }); ++ releases: [...releases.values()].map((incompleteRelease) => { ++ return _objectSpread( ++ _objectSpread({}, incompleteRelease), ++ {}, ++ { ++ newVersion: snapshotSuffix ++ ? getSnapshotVersion( ++ incompleteRelease, ++ preInfo, ++ refinedConfig.snapshot.useCalculatedVersion, ++ snapshotSuffix ++ ) ++ : getNewVersion(incompleteRelease, preInfo), ++ } ++ ); + }), +- preState: preInfo === null || preInfo === void 0 ? void 0 : preInfo.state ++ preState: preInfo === null || preInfo === void 0 ? void 0 : preInfo.state, + }; + } + +@@ -546,10 +674,12 @@ function getRelevantChangesets(changesets, packagesByName, config, preState) { + const notSkippedPackages = []; + + for (const release of changeset.releases) { +- if (shouldSkipPackage(packagesByName.get(release.name), { +- ignore: config.ignore, +- allowPrivatePackages: config.privatePackages.version +- })) { ++ if ( ++ shouldSkipPackage(packagesByName.get(release.name), { ++ ignore: config.ignore, ++ allowPrivatePackages: config.privatePackages.version, ++ }) ++ ) { + skippedPackages.push(release.name); + } else { + notSkippedPackages.push(release.name); +@@ -557,13 +687,20 @@ function getRelevantChangesets(changesets, packagesByName, config, preState) { + } + + if (skippedPackages.length > 0 && notSkippedPackages.length > 0) { +- throw new Error(`Found mixed changeset ${changeset.id}\n` + `Found ignored packages: ${skippedPackages.join(" ")}\n` + `Found not ignored packages: ${notSkippedPackages.join(" ")}\n` + "Mixed changesets that contain both ignored and not ignored packages are not allowed"); ++ throw new Error( ++ `Found mixed changeset ${changeset.id}\n` + ++ `Found ignored packages: ${skippedPackages.join(" ")}\n` + ++ `Found not ignored packages: ${notSkippedPackages.join(" ")}\n` + ++ "Mixed changesets that contain both ignored and not ignored packages are not allowed" ++ ); + } + } + + if (preState && preState.mode !== "exit") { + let usedChangesetIds = new Set(preState.changesets); +- return changesets.filter(changeset => !usedChangesetIds.has(changeset.id)); ++ return changesets.filter( ++ (changeset) => !usedChangesetIds.has(changeset.id) ++ ); + } + + return changesets; +@@ -573,7 +710,10 @@ function getHighestPreVersion(packageGroup, packagesByName) { + let highestPreVersion = 0; + + for (let pkg of packageGroup) { +- highestPreVersion = Math.max(getPreVersion(packagesByName.get(pkg).packageJson.version), highestPreVersion); ++ highestPreVersion = Math.max( ++ getPreVersion(packagesByName.get(pkg).packageJson.version), ++ highestPreVersion ++ ); + } + + return highestPreVersion; +@@ -584,23 +724,30 @@ function getPreInfo(changesets, packagesByName, config, preState) { + return; + } + +- let updatedPreState = _objectSpread(_objectSpread({}, preState), {}, { +- changesets: changesets.map(changeset => changeset.id), +- initialVersions: _objectSpread({}, preState.initialVersions) +- }); ++ let updatedPreState = _objectSpread( ++ _objectSpread({}, preState), ++ {}, ++ { ++ changesets: changesets.map((changeset) => changeset.id), ++ initialVersions: _objectSpread({}, preState.initialVersions), ++ } ++ ); + + for (const [, pkg] of packagesByName) { + if (updatedPreState.initialVersions[pkg.packageJson.name] === undefined) { +- updatedPreState.initialVersions[pkg.packageJson.name] = pkg.packageJson.version; ++ updatedPreState.initialVersions[pkg.packageJson.name] = ++ pkg.packageJson.version; + } + } // Populate preVersion + // preVersion is the map between package name and its next pre version number. + +- + let preVersions = new Map(); + + for (const [, pkg] of packagesByName) { +- preVersions.set(pkg.packageJson.name, getPreVersion(pkg.packageJson.version)); ++ preVersions.set( ++ pkg.packageJson.name, ++ getPreVersion(pkg.packageJson.version) ++ ); + } + + for (let fixedGroup of config.fixed) { +@@ -621,7 +768,7 @@ function getPreInfo(changesets, packagesByName, config, preState) { + + return { + state: updatedPreState, +- preVersions ++ preVersions, + }; + } + diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 224d37c79..736dd525b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -7,6 +7,11 @@ settings: overrides: flexsearch: 0.7.31 +patchedDependencies: + '@changesets/assemble-release-plan@6.0.1': + hash: zurdc2rhdwq47ocujld2bctf64 + path: patches/@changesets__assemble-release-plan@6.0.1.patch + importers: .: @@ -8534,7 +8539,7 @@ snapshots: resolve-from: 5.0.0 semver: 7.6.2 - '@changesets/assemble-release-plan@6.0.1': + '@changesets/assemble-release-plan@6.0.1(patch_hash=zurdc2rhdwq47ocujld2bctf64)': dependencies: '@babel/runtime': 7.24.6 '@changesets/errors': 0.2.0 @@ -8552,7 +8557,7 @@ snapshots: dependencies: '@babel/runtime': 7.24.6 '@changesets/apply-release-plan': 7.0.2 - '@changesets/assemble-release-plan': 6.0.1 + '@changesets/assemble-release-plan': 6.0.1(patch_hash=zurdc2rhdwq47ocujld2bctf64) '@changesets/changelog-git': 0.2.0 '@changesets/config': 3.0.0 '@changesets/errors': 0.2.0 @@ -8609,7 +8614,7 @@ snapshots: '@changesets/get-release-plan@4.0.1': dependencies: '@babel/runtime': 7.24.6 - '@changesets/assemble-release-plan': 6.0.1 + '@changesets/assemble-release-plan': 6.0.1(patch_hash=zurdc2rhdwq47ocujld2bctf64) '@changesets/config': 3.0.0 '@changesets/pre': 2.0.0 '@changesets/read': 0.6.0