{"version":3,"sources":["jsdelivr-header.js","/npm/@changesets/apply-release-plan@7.0.14/dist/changesets-apply-release-plan.cjs.js"],"names":[],"mappings":"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","file":"/npm/@changesets/apply-release-plan@7.0.14/dist/changesets-apply-release-plan.cjs.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@changesets/apply-release-plan@7.0.14/dist/changesets-apply-release-plan.cjs.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar config = require('@changesets/config');\nvar git = require('@changesets/git');\nvar shouldSkipPackage = require('@changesets/should-skip-package');\nvar detectIndent = require('detect-indent');\nvar fs = require('fs-extra');\nvar path = require('path');\nvar prettier = require('prettier');\nvar resolveFrom = require('resolve-from');\nvar startCase = require('lodash.startcase');\nvar semverSatisfies = require('semver/functions/satisfies');\nvar validRange = require('semver/ranges/valid');\nvar getVersionRangeType = require('@changesets/get-version-range-type');\nvar Range = require('semver/classes/range');\nvar semverPrerelease = require('semver/functions/prerelease');\n\nfunction _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }\n\nfunction _interopNamespace(e) {\n  if (e && e.__esModule) return e;\n  var n = Object.create(null);\n  if (e) {\n    Object.keys(e).forEach(function (k) {\n      if (k !== 'default') {\n        var d = Object.getOwnPropertyDescriptor(e, k);\n        Object.defineProperty(n, k, d.get ? d : {\n          enumerable: true,\n          get: function () { return e[k]; }\n        });\n      }\n    });\n  }\n  n[\"default\"] = e;\n  return Object.freeze(n);\n}\n\nvar git__namespace = /*#__PURE__*/_interopNamespace(git);\nvar detectIndent__default = /*#__PURE__*/_interopDefault(detectIndent);\nvar fs__default = /*#__PURE__*/_interopDefault(fs);\nvar path__default = /*#__PURE__*/_interopDefault(path);\nvar prettier__default = /*#__PURE__*/_interopDefault(prettier);\nvar resolveFrom__default = /*#__PURE__*/_interopDefault(resolveFrom);\nvar startCase__default = /*#__PURE__*/_interopDefault(startCase);\nvar semverSatisfies__default = /*#__PURE__*/_interopDefault(semverSatisfies);\nvar validRange__default = /*#__PURE__*/_interopDefault(validRange);\nvar getVersionRangeType__default = /*#__PURE__*/_interopDefault(getVersionRangeType);\nvar Range__default = /*#__PURE__*/_interopDefault(Range);\nvar semverPrerelease__default = /*#__PURE__*/_interopDefault(semverPrerelease);\n\nfunction _toPrimitive(t, r) {\n  if (\"object\" != typeof t || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != typeof i) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\n\nfunction _toPropertyKey(t) {\n  var i = _toPrimitive(t, \"string\");\n  return \"symbol\" == typeof i ? i : i + \"\";\n}\n\nfunction _defineProperty(e, r, t) {\n  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\n\nfunction ownKeys(e, r) {\n  var t = Object.keys(e);\n  if (Object.getOwnPropertySymbols) {\n    var o = Object.getOwnPropertySymbols(e);\n    r && (o = o.filter(function (r) {\n      return Object.getOwnPropertyDescriptor(e, r).enumerable;\n    })), t.push.apply(t, o);\n  }\n  return t;\n}\nfunction _objectSpread2(e) {\n  for (var r = 1; r < arguments.length; r++) {\n    var t = null != arguments[r] ? arguments[r] : {};\n    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {\n      _defineProperty(e, r, t[r]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\n      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\n    });\n  }\n  return e;\n}\n\n/**\n * Shared utility functions and business logic\n */\nconst bumpTypes = [\"none\", \"patch\", \"minor\", \"major\"];\n\n/* Converts a bump type into a numeric level to indicate order */\nfunction getBumpLevel(type) {\n  const level = bumpTypes.indexOf(type);\n  if (level < 0) {\n    throw new Error(`Unrecognised bump type ${type}`);\n  }\n  return level;\n}\nfunction shouldUpdateDependencyBasedOnConfig(release, {\n  depVersionRange,\n  depType\n}, {\n  minReleaseType,\n  onlyUpdatePeerDependentsWhenOutOfRange\n}) {\n  if (!semverSatisfies__default[\"default\"](release.version, depVersionRange)) {\n    // Dependencies leaving semver range should always be updated\n    return true;\n  }\n  const minLevel = getBumpLevel(minReleaseType);\n  let shouldUpdate = getBumpLevel(release.type) >= minLevel;\n  if (depType === \"peerDependencies\") {\n    shouldUpdate = !onlyUpdatePeerDependentsWhenOutOfRange;\n  }\n  return shouldUpdate;\n}\n\nasync function generateChangesForVersionTypeMarkdown(obj, type) {\n  let releaseLines = await Promise.all(obj[type]);\n  releaseLines = releaseLines.filter(x => x);\n  if (releaseLines.length) {\n    return `### ${startCase__default[\"default\"](type)} Changes\\n\\n${releaseLines.join(\"\\n\")}\\n`;\n  }\n}\n\n// release is the package and version we are releasing\nasync function getChangelogEntry(release, releases, changesets, changelogFuncs, changelogOpts, {\n  updateInternalDependencies,\n  onlyUpdatePeerDependentsWhenOutOfRange\n}) {\n  if (release.type === \"none\") return null;\n  const changelogLines = {\n    major: [],\n    minor: [],\n    patch: []\n  };\n\n  // I sort of feel we can do better, as ComprehensiveReleases have an array\n  // of the relevant changesets but since we need the version type for the\n  // release in the changeset, I don't know if we can\n  // We can filter here, but that just adds another iteration over this list\n  changesets.forEach(cs => {\n    const rls = cs.releases.find(r => r.name === release.name);\n    if (rls && rls.type !== \"none\") {\n      changelogLines[rls.type].push(changelogFuncs.getReleaseLine(cs, rls.type, changelogOpts));\n    }\n  });\n  let dependentReleases = releases.filter(rel => {\n    var _release$packageJson$, _release$packageJson$2;\n    const dependencyVersionRange = (_release$packageJson$ = release.packageJson.dependencies) === null || _release$packageJson$ === void 0 ? void 0 : _release$packageJson$[rel.name];\n    const peerDependencyVersionRange = (_release$packageJson$2 = release.packageJson.peerDependencies) === null || _release$packageJson$2 === void 0 ? void 0 : _release$packageJson$2[rel.name];\n    const versionRange = dependencyVersionRange || peerDependencyVersionRange;\n    const usesWorkspaceRange = versionRange === null || versionRange === void 0 ? void 0 : versionRange.startsWith(\"workspace:\");\n    return versionRange && (usesWorkspaceRange || validRange__default[\"default\"](versionRange) !== null) && shouldUpdateDependencyBasedOnConfig({\n      type: rel.type,\n      version: rel.newVersion\n    }, {\n      depVersionRange: versionRange,\n      depType: dependencyVersionRange ? \"dependencies\" : \"peerDependencies\"\n    }, {\n      minReleaseType: updateInternalDependencies,\n      onlyUpdatePeerDependentsWhenOutOfRange\n    });\n  });\n  let relevantChangesetIds = new Set();\n  dependentReleases.forEach(rel => {\n    rel.changesets.forEach(cs => {\n      relevantChangesetIds.add(cs);\n    });\n  });\n  let relevantChangesets = changesets.filter(cs => relevantChangesetIds.has(cs.id));\n  changelogLines.patch.push(changelogFuncs.getDependencyReleaseLine(relevantChangesets, dependentReleases, changelogOpts));\n  return [`## ${release.newVersion}`, await generateChangesForVersionTypeMarkdown(changelogLines, \"major\"), await generateChangesForVersionTypeMarkdown(changelogLines, \"minor\"), await generateChangesForVersionTypeMarkdown(changelogLines, \"patch\")].filter(line => line).join(\"\\n\");\n}\n\nconst DEPENDENCY_TYPES = [\"dependencies\", \"devDependencies\", \"peerDependencies\", \"optionalDependencies\"];\nfunction versionPackage(release, versionsToUpdate, {\n  updateInternalDependencies,\n  onlyUpdatePeerDependentsWhenOutOfRange,\n  bumpVersionsWithWorkspaceProtocolOnly,\n  snapshot\n}) {\n  let {\n    newVersion,\n    packageJson\n  } = release;\n  packageJson.version = newVersion;\n  for (let depType of DEPENDENCY_TYPES) {\n    let deps = packageJson[depType];\n    if (deps) {\n      for (let {\n        name,\n        version,\n        type\n      } of versionsToUpdate) {\n        let depCurrentVersion = deps[name];\n        if (!depCurrentVersion || depCurrentVersion.startsWith(\"file:\") || depCurrentVersion.startsWith(\"link:\") || !shouldUpdateDependencyBasedOnConfig({\n          version,\n          type\n        }, {\n          depVersionRange: depCurrentVersion,\n          depType\n        }, {\n          minReleaseType: updateInternalDependencies,\n          onlyUpdatePeerDependentsWhenOutOfRange\n        })) {\n          continue;\n        }\n        const usesWorkspaceRange = depCurrentVersion.startsWith(\"workspace:\");\n        if (!usesWorkspaceRange && (bumpVersionsWithWorkspaceProtocolOnly || validRange__default[\"default\"](depCurrentVersion) === null)) {\n          continue;\n        }\n        if (usesWorkspaceRange) {\n          const workspaceDepVersion = depCurrentVersion.replace(/^workspace:/, \"\");\n          if (workspaceDepVersion === \"*\" || workspaceDepVersion === \"^\" || workspaceDepVersion === \"~\") {\n            continue;\n          }\n          depCurrentVersion = workspaceDepVersion;\n        }\n        if (\n        // an empty string is the normalised version of x/X/*\n        // we don't want to change these versions because they will match\n        // any version and if someone makes the range that\n        // they probably want it to stay like that...\n        new Range__default[\"default\"](depCurrentVersion).range !== \"\" ||\n        // ...unless the current version of a dependency is a prerelease (which doesn't satisfy x/X/*)\n        // leaving those as is would leave the package in a non-installable state (wrong dep versions would get installed)\n        semverPrerelease__default[\"default\"](version) !== null) {\n          let newNewRange = snapshot ? version : `${getVersionRangeType__default[\"default\"](depCurrentVersion)}${version}`;\n          if (usesWorkspaceRange) newNewRange = `workspace:${newNewRange}`;\n          deps[name] = newNewRange;\n        }\n      }\n    }\n  }\n  return _objectSpread2(_objectSpread2({}, release), {}, {\n    packageJson\n  });\n}\n\nfunction getPrettierInstance(cwd) {\n  try {\n    return require(require.resolve(\"prettier\", {\n      paths: [cwd]\n    }));\n  } catch (err) {\n    if (!err || err.code !== \"MODULE_NOT_FOUND\") {\n      throw err;\n    }\n    return prettier__default[\"default\"];\n  }\n}\nfunction stringDefined(s) {\n  return !!s;\n}\nasync function getCommitsThatAddChangesets(changesetIds, cwd) {\n  const paths = changesetIds.map(id => `.changeset/${id}.md`);\n  const commits = await git__namespace.getCommitsThatAddFiles(paths, {\n    cwd\n  });\n  if (commits.every(stringDefined)) {\n    // We have commits for all files\n    return commits;\n  }\n\n  // Some files didn't exist. Try legacy filenames instead\n  const missingIds = changesetIds.map((id, i) => commits[i] ? undefined : id).filter(stringDefined);\n  const legacyPaths = missingIds.map(id => `.changeset/${id}/changes.json`);\n  const commitsForLegacyPaths = await git__namespace.getCommitsThatAddFiles(legacyPaths, {\n    cwd\n  });\n\n  // Fill in the blanks in the array of commits\n  changesetIds.forEach((id, i) => {\n    if (!commits[i]) {\n      const missingIndex = missingIds.indexOf(id);\n      commits[i] = commitsForLegacyPaths[missingIndex];\n    }\n  });\n  return commits;\n}\nasync function applyReleasePlan(releasePlan, packages, config$1 = config.defaultConfig, snapshot, contextDir = __dirname) {\n  let cwd = packages.root.dir;\n  let touchedFiles = [];\n  const packagesByName = new Map(packages.packages.map(x => [x.packageJson.name, x]));\n  let {\n    releases,\n    changesets\n  } = releasePlan;\n  let releasesWithPackage = releases.map(release => {\n    let pkg = packagesByName.get(release.name);\n    if (!pkg) throw new Error(`Could not find matching package for release of: ${release.name}`);\n    return _objectSpread2(_objectSpread2({}, release), pkg);\n  });\n\n  // I think this might be the wrong place to do this, but gotta do it somewhere -  add changelog entries to releases\n  let releaseWithChangelogs = await getNewChangelogEntry(releasesWithPackage, changesets, config$1, cwd, contextDir);\n  if (releasePlan.preState !== undefined && snapshot === undefined) {\n    if (releasePlan.preState.mode === \"exit\") {\n      await fs__default[\"default\"].remove(path__default[\"default\"].join(cwd, \".changeset\", \"pre.json\"));\n    } else {\n      await fs__default[\"default\"].writeFile(path__default[\"default\"].join(cwd, \".changeset\", \"pre.json\"), JSON.stringify(releasePlan.preState, null, 2) + \"\\n\");\n    }\n    touchedFiles.push(path__default[\"default\"].join(cwd, \".changeset\", \"pre.json\"));\n  }\n  let versionsToUpdate = releases.map(({\n    name,\n    newVersion,\n    type\n  }) => ({\n    name,\n    version: newVersion,\n    type\n  }));\n\n  // iterate over releases updating packages\n  let finalisedRelease = releaseWithChangelogs.map(release => {\n    return versionPackage(release, versionsToUpdate, {\n      updateInternalDependencies: config$1.updateInternalDependencies,\n      onlyUpdatePeerDependentsWhenOutOfRange: config$1.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.onlyUpdatePeerDependentsWhenOutOfRange,\n      bumpVersionsWithWorkspaceProtocolOnly: config$1.bumpVersionsWithWorkspaceProtocolOnly,\n      snapshot\n    });\n  });\n  let prettierInstance = config$1.prettier !== false ? getPrettierInstance(cwd) : undefined;\n  for (let release of finalisedRelease) {\n    let {\n      changelog,\n      packageJson,\n      dir,\n      name\n    } = release;\n    const pkgJSONPath = path__default[\"default\"].resolve(dir, \"package.json\");\n    await updatePackageJson(pkgJSONPath, packageJson);\n    touchedFiles.push(pkgJSONPath);\n    if (changelog && changelog.length > 0) {\n      const changelogPath = path__default[\"default\"].resolve(dir, \"CHANGELOG.md\");\n      await updateChangelog(changelogPath, changelog, name, prettierInstance);\n      touchedFiles.push(changelogPath);\n    }\n  }\n  if (releasePlan.preState === undefined || releasePlan.preState.mode === \"exit\") {\n    let changesetFolder = path__default[\"default\"].resolve(cwd, \".changeset\");\n    await Promise.all(changesets.map(async changeset => {\n      let changesetPath = path__default[\"default\"].resolve(changesetFolder, `${changeset.id}.md`);\n      let changesetFolderPath = path__default[\"default\"].resolve(changesetFolder, changeset.id);\n      if (await fs__default[\"default\"].pathExists(changesetPath)) {\n        // DO NOT remove changeset for skipped packages\n        // Mixed changeset that contains both skipped packages and not skipped packages are disallowed\n        // At this point, we know there is no such changeset, because otherwise the program would've already failed,\n        // so we just check if any skipped package exists in this changeset, and only remove it if none exists\n        // options to skip packages were added in v2, so we don't need to do it for v1 changesets\n        if (!changeset.releases.find(release => shouldSkipPackage.shouldSkipPackage(packagesByName.get(release.name), {\n          ignore: config$1.ignore,\n          allowPrivatePackages: config$1.privatePackages.version\n        }))) {\n          touchedFiles.push(changesetPath);\n          await fs__default[\"default\"].remove(changesetPath);\n        }\n        // TO REMOVE LOGIC - this works to remove v1 changesets. We should be removed in the future\n      } else if (await fs__default[\"default\"].pathExists(changesetFolderPath)) {\n        touchedFiles.push(changesetFolderPath);\n        await fs__default[\"default\"].remove(changesetFolderPath);\n      }\n    }));\n  }\n\n  // We return the touched files to be committed in the cli\n  return touchedFiles;\n}\nasync function getNewChangelogEntry(releasesWithPackage, changesets, config, cwd, contextDir) {\n  if (!config.changelog) {\n    return Promise.resolve(releasesWithPackage.map(release => _objectSpread2(_objectSpread2({}, release), {}, {\n      changelog: null\n    })));\n  }\n  let getChangelogFuncs = {\n    getReleaseLine: () => Promise.resolve(\"\"),\n    getDependencyReleaseLine: () => Promise.resolve(\"\")\n  };\n  const changelogOpts = config.changelog[1];\n  let changesetPath = path__default[\"default\"].join(cwd, \".changeset\");\n  let changelogPath;\n  try {\n    changelogPath = resolveFrom__default[\"default\"](changesetPath, config.changelog[0]);\n  } catch (_unused) {\n    changelogPath = resolveFrom__default[\"default\"](contextDir, config.changelog[0]);\n  }\n  let possibleChangelogFunc = require(changelogPath);\n  if (possibleChangelogFunc.default) {\n    possibleChangelogFunc = possibleChangelogFunc.default;\n  }\n  if (typeof possibleChangelogFunc.getReleaseLine === \"function\" && typeof possibleChangelogFunc.getDependencyReleaseLine === \"function\") {\n    getChangelogFuncs = possibleChangelogFunc;\n  } else {\n    throw new Error(\"Could not resolve changelog generation functions\");\n  }\n  let commits = await getCommitsThatAddChangesets(changesets.map(cs => cs.id), cwd);\n  let moddedChangesets = changesets.map((cs, i) => _objectSpread2(_objectSpread2({}, cs), {}, {\n    commit: commits[i]\n  }));\n  return Promise.all(releasesWithPackage.map(async release => {\n    let changelog = await getChangelogEntry(release, releasesWithPackage, moddedChangesets, getChangelogFuncs, changelogOpts, {\n      updateInternalDependencies: config.updateInternalDependencies,\n      onlyUpdatePeerDependentsWhenOutOfRange: config.___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH.onlyUpdatePeerDependentsWhenOutOfRange\n    });\n    return _objectSpread2(_objectSpread2({}, release), {}, {\n      changelog\n    });\n  })).catch(e => {\n    console.error(\"The following error was encountered while generating changelog entries\");\n    console.error(\"We have escaped applying the changesets, and no files should have been affected\");\n    throw e;\n  });\n}\nasync function updateChangelog(changelogPath, changelog, name, prettierInstance) {\n  let templateString = `\\n\\n${changelog.trim()}\\n`;\n  try {\n    if (fs__default[\"default\"].existsSync(changelogPath)) {\n      await prependFile(changelogPath, templateString, name, prettierInstance);\n    } else {\n      await writeFormattedMarkdownFile(changelogPath, `# ${name}${templateString}`, prettierInstance);\n    }\n  } catch (e) {\n    console.warn(e);\n  }\n}\nasync function updatePackageJson(pkgJsonPath, pkgJson) {\n  const pkgRaw = await fs__default[\"default\"].readFile(pkgJsonPath, \"utf-8\");\n  const indent = detectIndent__default[\"default\"](pkgRaw).indent || \"  \";\n  const stringified = JSON.stringify(pkgJson, null, indent) + (pkgRaw.endsWith(\"\\n\") ? \"\\n\" : \"\");\n  return fs__default[\"default\"].writeFile(pkgJsonPath, stringified);\n}\nasync function prependFile(filePath, data, name, prettierInstance) {\n  const fileData = fs__default[\"default\"].readFileSync(filePath).toString();\n  // if the file exists but doesn't have the header, we'll add it in\n  if (!fileData) {\n    const completelyNewChangelog = `# ${name}${data}`;\n    await writeFormattedMarkdownFile(filePath, completelyNewChangelog, prettierInstance);\n    return;\n  }\n  const index = fileData.indexOf(\"\\n\");\n  const newChangelog = index === -1 ? fileData + data // treat the whole file as header\n  : fileData.slice(0, index) + data + fileData.slice(index + 1);\n  await writeFormattedMarkdownFile(filePath, newChangelog, prettierInstance);\n}\nasync function writeFormattedMarkdownFile(filePath, content, prettierInstance) {\n  await fs__default[\"default\"].writeFile(filePath, prettierInstance ?\n  // Prettier v3 returns a promise\n  await prettierInstance.format(content, _objectSpread2(_objectSpread2({}, await prettierInstance.resolveConfig(filePath)), {}, {\n    filepath: filePath,\n    parser: \"markdown\"\n  })) : content);\n}\n\nexports[\"default\"] = applyReleasePlan;\n"]}