@yarnpkg/plugin-essentials 3.2.0 → 4.0.0-rc.3

package/lib/commands/add.d.ts

@@ -5,6 +5,7 @@ export default class AddCommand extends BaseCommand {
     static paths: string[][];
     static usage: Usage;
     json: boolean;
+    fixed: boolean;
     exact: boolean;
     tilde: boolean;
     caret: boolean;

package/lib/commands/add.js

@@ -16,6 +16,9 @@ class AddCommand extends cli_1.BaseCommand {
         this.json = clipanion_1.Option.Boolean(`--json`, false, {
             description: `Format the output as an NDJSON stream`,
         });
+        this.fixed = clipanion_1.Option.Boolean(`-F,--fixed`, false, {
+            description: `Store dependency tags as-is instead of resolving them`,
+        });
         this.exact = clipanion_1.Option.Boolean(`-E,--exact`, false, {
             description: `Don't use any semver modifier on the resolved range`,
         });
@@ -60,18 +63,20 @@ class AddCommand extends cli_1.BaseCommand {
         await project.restoreInstallState({
             restoreResolutions: false,
         });
+        const fixed = this.fixed;
         const interactive = (_a = this.interactive) !== null && _a !== void 0 ? _a : configuration.get(`preferInteractive`);
+        const reuse = interactive || configuration.get(`preferReuse`);
         const modifier = suggestUtils.getModifier(this, project);
         const strategies = [
-            ...interactive ? [
-                suggestUtils.Strategy.REUSE,
-            ] : [],
+            reuse ?
+                suggestUtils.Strategy.REUSE
+                : undefined,
             suggestUtils.Strategy.PROJECT,
-            ...this.cached ? [
-                suggestUtils.Strategy.CACHE,
-            ] : [],
+            this.cached ?
+                suggestUtils.Strategy.CACHE
+                : undefined,
             suggestUtils.Strategy.LATEST,
-        ];
+        ].filter((strategy) => typeof strategy !== `undefined`);
         const maxResults = interactive
             ? Infinity
             : 1;
@@ -90,7 +95,7 @@ class AddCommand extends cli_1.BaseCommand {
                 preferDev: this.preferDev,
                 optional: this.optional,
             });
-            const suggestions = await suggestUtils.getSuggestedDescriptors(request, { project, workspace, cache, target, modifier, strategies, maxResults });
+            const suggestions = await suggestUtils.getSuggestedDescriptors(request, { project, workspace, cache, fixed, target, modifier, strategies, maxResults });
             return [request, suggestions, target];
         }));
         const checkReport = await core_1.LightReport.start({

package/lib/commands/install.d.ts

@@ -7,7 +7,9 @@ export default class YarnCommand extends BaseCommand {
     json: boolean;
     immutable: boolean | undefined;
     immutableCache: boolean | undefined;
-    checkCache: boolean;
+    refreshLockfile: boolean | undefined;
+    checkCache: boolean | undefined;
+    checkResolutions: boolean | undefined;
     inlineBuilds: boolean | undefined;
     mode: InstallMode | undefined;
     cacheFolder: string | undefined;

package/lib/commands/install.js

@@ -21,9 +21,15 @@ class YarnCommand extends cli_1.BaseCommand {
         this.immutableCache = clipanion_1.Option.Boolean(`--immutable-cache`, {
             description: `Abort with an error exit code if the cache folder was to be modified`,
         });
-        this.checkCache = clipanion_1.Option.Boolean(`--check-cache`, false, {
+        this.refreshLockfile = clipanion_1.Option.Boolean(`--refresh-lockfile`, {
+            description: `Refresh the package metadata stored in the lockfile`,
+        });
+        this.checkCache = clipanion_1.Option.Boolean(`--check-cache`, {
             description: `Always refetch the packages and ensure that their checksums are consistent`,
         });
+        this.checkResolutions = clipanion_1.Option.Boolean(`--check-resolutions`, {
+            description: `Validates that the package resolutions are coherent`,
+        });
         this.inlineBuilds = clipanion_1.Option.Boolean(`--inline-builds`, {
             description: `Verbosely print the output of the build steps of dependencies`,
         });
@@ -43,7 +49,7 @@ class YarnCommand extends cli_1.BaseCommand {
         this.networkTimeout = clipanion_1.Option.String(`--network-timeout`, { hidden: true });
     }
     async execute() {
-        var _a;
+        var _a, _b, _c;
         const configuration = await core_1.Configuration.find(this.context.cwd, this.context.plugins);
         if (typeof this.inlineBuilds !== `undefined`)
             configuration.useWithSource(`<cli>`, { enableInlineBuilds: this.inlineBuilds }, configuration.startingCwd, { overwrite: true });
@@ -228,6 +234,10 @@ class YarnCommand extends cli_1.BaseCommand {
         await project.restoreInstallState({
             restoreResolutions: false,
         });
+        const enableHardenedMode = configuration.get(`enableHardenedMode`);
+        if ((_b = this.refreshLockfile) !== null && _b !== void 0 ? _b : enableHardenedMode)
+            project.lockfileNeedsRefresh = true;
+        const checkResolutions = (_c = this.checkResolutions) !== null && _c !== void 0 ? _c : enableHardenedMode;
         // Important: Because other commands also need to run installs, if you
         // get in a situation where you need to change this file in order to
         // customize the install it's very likely you're doing something wrong.
@@ -241,7 +251,7 @@ class YarnCommand extends cli_1.BaseCommand {
             stdout: this.context.stdout,
             includeLogs: true,
         }, async (report) => {
-            await project.install({ cache, report, immutable, mode: this.mode });
+            await project.install({ cache, report, immutable, checkResolutions, mode: this.mode });
         });
         return report.exitCode();
     }
@@ -270,6 +280,8 @@ YarnCommand.usage = clipanion_1.Command.Usage({
 
       If the \`--immutable-cache\` option is set, Yarn will abort with an error exit code if the cache folder was to be modified (either because files would be added, or because they'd be removed).
 
+      If the \`--refresh-lockfile\` option is set, Yarn will keep the same resolution for the packages currently in the lockfile but will refresh their metadata. If used together with \`--immutable\`, it can validate that the lockfile information are consistent. This flag is enabled by default when Yarn detects it runs within a pull request context.
+
       If the \`--check-cache\` option is set, Yarn will always refetch the packages and will ensure that their checksum matches what's 1/ described in the lockfile 2/ inside the existing cache files (if present). This is recommended as part of your CI workflow if you're both following the Zero-Installs model and accepting PRs from third-parties, as they'd otherwise have the ability to alter the checked-in packages before submitting them.
 
       If the \`--inline-builds\` option is set, Yarn will verbosely print the output of the build steps of your dependencies (instead of writing them into individual files). This is likely useful mostly for debug purposes only when using Docker-like environments.

package/lib/commands/plugin/import/sources.js

@@ -46,7 +46,7 @@ class PluginDlSourcesCommand extends cli_1.BaseCommand {
             const { project } = await core_2.Project.find(configuration, this.context.cwd);
             const ident = core_1.structUtils.parseIdent(this.name.replace(/^((@yarnpkg\/)?plugin-)?/, `@yarnpkg/plugin-`));
             const identStr = core_1.structUtils.stringifyIdent(ident);
-            const data = await (0, list_1.getAvailablePlugins)(configuration);
+            const data = await (0, list_1.getAvailablePlugins)(configuration, core_1.YarnVersion);
             if (!Object.prototype.hasOwnProperty.call(data, identStr))
                 throw new core_2.ReportError(core_2.MessageName.PLUGIN_NAME_NOT_FOUND, `Couldn't find a plugin named "${identStr}" on the remote registry. Note that only the plugins referenced on our website (https://github.com/yarnpkg/berry/blob/master/plugins.yml) can be built and imported from sources.`);
             const pluginSpec = identStr;

package/lib/commands/plugin/import.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { BaseCommand } from '@yarnpkg/cli';
 import { Project, Report } from '@yarnpkg/core';
 import { Usage } from 'clipanion';

package/lib/commands/plugin/import.js

@@ -49,9 +49,15 @@ class PluginDlCommand extends cli_1.BaseCommand {
                     if (locator.reference !== `unknown` && !semver_1.default.valid(locator.reference))
                         throw new core_1.ReportError(core_1.MessageName.UNNAMED, `Official plugins only accept strict version references. Use an explicit URL if you wish to download them from another location.`);
                     const identStr = core_2.structUtils.stringifyIdent(locator);
-                    const data = await (0, list_1.getAvailablePlugins)(configuration);
-                    if (!Object.prototype.hasOwnProperty.call(data, identStr))
-                        throw new core_1.ReportError(core_1.MessageName.PLUGIN_NAME_NOT_FOUND, `Couldn't find a plugin named "${identStr}" on the remote registry. Note that only the plugins referenced on our website (https://github.com/yarnpkg/berry/blob/master/plugins.yml) can be referenced by their name; any other plugin will have to be referenced through its public url (for example https://github.com/yarnpkg/berry/raw/master/packages/plugin-typescript/bin/%40yarnpkg/plugin-typescript.js).`);
+                    const data = await (0, list_1.getAvailablePlugins)(configuration, core_2.YarnVersion);
+                    if (!Object.prototype.hasOwnProperty.call(data, identStr)) {
+                        let message = `Couldn't find a plugin named ${core_2.structUtils.prettyIdent(configuration, locator)} on the remote registry.\n`;
+                        if (configuration.plugins.has(identStr))
+                            message += `A plugin named ${core_2.structUtils.prettyIdent(configuration, locator)} is already installed; possibly attempting to import a built-in plugin.`;
+                        else
+                            message += `Note that only the plugins referenced on our website (${core_2.formatUtils.pretty(configuration, `https://github.com/yarnpkg/berry/blob/master/plugins.yml`, core_2.formatUtils.Type.URL)}) can be referenced by their name; any other plugin will have to be referenced through its public url (for example ${core_2.formatUtils.pretty(configuration, `https://github.com/yarnpkg/berry/raw/master/packages/plugin-typescript/bin/%40yarnpkg/plugin-typescript.js`, core_2.formatUtils.Type.URL)}).`;
+                        throw new core_1.ReportError(core_1.MessageName.PLUGIN_NAME_NOT_FOUND, message);
+                    }
                     pluginSpec = identStr;
                     pluginUrl = data[identStr].url;
                     if (locator.reference !== `unknown`) {

package/lib/commands/plugin/list.d.ts

@@ -1,8 +1,8 @@
 import { BaseCommand } from '@yarnpkg/cli';
 import { Configuration } from '@yarnpkg/core';
 import { Usage } from 'clipanion';
-export declare function getAvailablePlugins(configuration: Configuration): Promise<{
-    [key: string]: any;
+export declare function getAvailablePlugins(configuration: Configuration, version: string | null): Promise<{
+    [k: string]: any;
 }>;
 export default class PluginDlCommand extends BaseCommand {
     static paths: string[][];

package/lib/commands/plugin/list.js

@@ -6,10 +6,13 @@ const core_1 = require("@yarnpkg/core");
 const parsers_1 = require("@yarnpkg/parsers");
 const clipanion_1 = require("clipanion");
 const REMOTE_REGISTRY = `https://raw.githubusercontent.com/yarnpkg/berry/master/plugins.yml`;
-async function getAvailablePlugins(configuration) {
+async function getAvailablePlugins(configuration, version) {
     const raw = await core_1.httpUtils.get(REMOTE_REGISTRY, { configuration });
     const data = (0, parsers_1.parseSyml)(raw.toString());
-    return data;
+    return Object.fromEntries(Object.entries(data).filter(([pluginName, pluginData]) => {
+        var _a;
+        return !version || core_1.semverUtils.satisfiesWithPrereleases(version, (_a = pluginData.range) !== null && _a !== void 0 ? _a : `<4.0.0-rc.1`);
+    }));
 }
 exports.getAvailablePlugins = getAvailablePlugins;
 // eslint-disable-next-line arca/no-default-export
@@ -27,7 +30,7 @@ class PluginDlCommand extends cli_1.BaseCommand {
             json: this.json,
             stdout: this.context.stdout,
         }, async (report) => {
-            const data = await getAvailablePlugins(configuration);
+            const data = await getAvailablePlugins(configuration, core_1.YarnVersion);
             for (const [name, { experimental, ...rest }] of Object.entries(data)) {
                 let label = name;
                 if (experimental)

package/lib/commands/run.d.ts

@@ -7,6 +7,7 @@ export default class RunCommand extends BaseCommand {
     inspectBrk: string | boolean;
     topLevel: boolean;
     binariesOnly: boolean;
+    require: string | undefined;
     silent: boolean | undefined;
     scriptName: string;
     args: string[];

package/lib/commands/run.js

@@ -22,6 +22,9 @@ class RunCommand extends cli_1.BaseCommand {
         this.binariesOnly = clipanion_1.Option.Boolean(`-B,--binaries-only`, false, {
             description: `Ignore any user defined scripts and only check for binaries`,
         });
+        this.require = clipanion_1.Option.String(`--require`, {
+            description: `Forwarded to the underlying Node process when executing a binary`,
+        });
         // The v1 used to print the Yarn version header when using "yarn run", which
         // was messing with the output of things like `--version` & co. We don't do
         // this anymore, but many workflows use `yarn run --silent` to make sure that
@@ -64,6 +67,8 @@ class RunCommand extends cli_1.BaseCommand {
                     nodeArgs.push(`--inspect-brk`);
                 }
             }
+            if (this.require)
+                nodeArgs.push(`--require=${this.require}`);
             return await core_2.scriptUtils.executePackageAccessibleBinary(effectiveLocator, this.scriptName, this.args, {
                 cwd: this.context.cwd,
                 project,

package/lib/commands/set/version/sources.js

@@ -76,11 +76,11 @@ class SetVersionSourcesCommand extends cli_1.BaseCommand {
             report.reportSeparator();
             const bundlePath = fslib_1.ppath.resolve(target, `packages/yarnpkg-cli/bundles/yarn.js`);
             const bundleBuffer = await fslib_1.xfs.readFilePromise(bundlePath);
-            await (0, version_1.setVersion)(configuration, `sources`, bundleBuffer, {
+            const { bundleVersion } = await (0, version_1.setVersion)(configuration, null, async () => bundleBuffer, {
                 report,
             });
             if (!this.skipPlugins) {
-                await updatePlugins(this, { project, report, target });
+                await updatePlugins(this, bundleVersion, { project, report, target });
             }
         });
         return report.exitCode();
@@ -155,8 +155,8 @@ async function prepareRepo(spec, { configuration, report, target }) {
     }
 }
 exports.prepareRepo = prepareRepo;
-async function updatePlugins(context, { project, report, target }) {
-    const data = await (0, list_1.getAvailablePlugins)(project.configuration);
+async function updatePlugins(context, version, { project, report, target }) {
+    const data = await (0, list_1.getAvailablePlugins)(project.configuration, version);
     const contribPlugins = new Set(Object.keys(data));
     for (const name of project.configuration.plugins.keys()) {
         if (!contribPlugins.has(name))

package/lib/commands/set/version.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { BaseCommand } from '@yarnpkg/cli';
 import { Configuration, Report } from '@yarnpkg/core';
 import { Usage } from 'clipanion';
@@ -9,12 +10,16 @@ export declare type Tags = {
 export default class SetVersionCommand extends BaseCommand {
     static paths: string[][];
     static usage: Usage;
+    useYarnPath: boolean | undefined;
     onlyIfNeeded: boolean;
     version: string;
     execute(): Promise<1 | 0>;
 }
 export declare function resolveRange(configuration: Configuration, request: string): Promise<string>;
 export declare function resolveTag(configuration: Configuration, request: `stable` | `canary`): Promise<string>;
-export declare function setVersion(configuration: Configuration, bundleVersion: string | null, bundleBuffer: Buffer, { report }: {
+export declare function setVersion(configuration: Configuration, bundleVersion: string | null, fetchBuffer: () => Promise<Buffer>, { report, useYarnPath }: {
     report: Report;
-}): Promise<void>;
+    useYarnPath?: boolean;
+}): Promise<{
+    bundleVersion: string;
+}>;

package/lib/commands/set/version.js

@@ -12,6 +12,9 @@ const semver_1 = tslib_1.__importDefault(require("semver"));
 class SetVersionCommand extends cli_1.BaseCommand {
     constructor() {
         super(...arguments);
+        this.useYarnPath = clipanion_1.Option.Boolean(`--yarn-path`, {
+            description: `Set the yarnPath setting even if the version can be accessed by Corepack`,
+        });
         this.onlyIfNeeded = clipanion_1.Option.Boolean(`--only-if-needed`, false, {
             description: `Only lock the Yarn version if it isn't already locked`,
         });
@@ -26,25 +29,28 @@ class SetVersionCommand extends cli_1.BaseCommand {
                 throw new clipanion_1.UsageError(`The --install flag can only be used without explicit version specifier from the Yarn CLI`);
             return `file://${process.argv[1]}`;
         };
-        let bundleUrl;
+        let bundleRef;
+        const getRef = (url, version) => {
+            return { version, url: url.replace(/\{\}/g, version) };
+        };
         if (this.version === `self`)
-            bundleUrl = getBundlePath();
+            bundleRef = { url: getBundlePath(), version: core_1.YarnVersion !== null && core_1.YarnVersion !== void 0 ? core_1.YarnVersion : `self` };
         else if (this.version === `latest` || this.version === `berry` || this.version === `stable`)
-            bundleUrl = `https://repo.yarnpkg.com/${await resolveTag(configuration, `stable`)}/packages/yarnpkg-cli/bin/yarn.js`;
+            bundleRef = getRef(`https://repo.yarnpkg.com/{}/packages/yarnpkg-cli/bin/yarn.js`, await resolveTag(configuration, `stable`));
         else if (this.version === `canary`)
-            bundleUrl = `https://repo.yarnpkg.com/${await resolveTag(configuration, `canary`)}/packages/yarnpkg-cli/bin/yarn.js`;
+            bundleRef = getRef(`https://repo.yarnpkg.com/{}/packages/yarnpkg-cli/bin/yarn.js`, await resolveTag(configuration, `canary`));
         else if (this.version === `classic`)
-            bundleUrl = `https://nightly.yarnpkg.com/latest.js`;
+            bundleRef = { url: `https://nightly.yarnpkg.com/latest.js`, version: `classic` };
         else if (this.version.match(/^https?:/))
-            bundleUrl = this.version;
+            bundleRef = { url: this.version, version: `remote` };
         else if (this.version.match(/^\.{0,2}[\\/]/) || fslib_1.npath.isAbsolute(this.version))
-            bundleUrl = `file://${fslib_1.npath.resolve(this.version)}`;
+            bundleRef = { url: `file://${fslib_1.ppath.resolve(fslib_1.npath.toPortablePath(this.version))}`, version: `file` };
         else if (core_2.semverUtils.satisfiesWithPrereleases(this.version, `>=2.0.0`))
-            bundleUrl = `https://repo.yarnpkg.com/${this.version}/packages/yarnpkg-cli/bin/yarn.js`;
+            bundleRef = getRef(`https://repo.yarnpkg.com/{}/packages/yarnpkg-cli/bin/yarn.js`, this.version);
         else if (core_2.semverUtils.satisfiesWithPrereleases(this.version, `^0.x || ^1.x`))
-            bundleUrl = `https://github.com/yarnpkg/yarn/releases/download/v${this.version}/yarn-${this.version}.js`;
+            bundleRef = getRef(`https://github.com/yarnpkg/yarn/releases/download/v{}/yarn-{}.js`, this.version);
         else if (core_2.semverUtils.validRange(this.version))
-            bundleUrl = `https://repo.yarnpkg.com/${await resolveRange(configuration, this.version)}/packages/yarnpkg-cli/bin/yarn.js`;
+            bundleRef = getRef(`https://repo.yarnpkg.com/{}/packages/yarnpkg-cli/bin/yarn.js`, await resolveRange(configuration, this.version));
         else
             throw new clipanion_1.UsageError(`Invalid version descriptor "${this.version}"`);
         const report = await core_1.StreamReport.start({
@@ -52,17 +58,18 @@ class SetVersionCommand extends cli_1.BaseCommand {
             stdout: this.context.stdout,
             includeLogs: !this.context.quiet,
         }, async (report) => {
-            const filePrefix = `file://`;
-            let bundleBuffer;
-            if (bundleUrl.startsWith(filePrefix)) {
-                report.reportInfo(core_1.MessageName.UNNAMED, `Downloading ${core_2.formatUtils.pretty(configuration, bundleUrl, core_1.FormatType.URL)}`);
-                bundleBuffer = await fslib_1.xfs.readFilePromise(fslib_1.npath.toPortablePath(bundleUrl.slice(filePrefix.length)));
-            }
-            else {
-                report.reportInfo(core_1.MessageName.UNNAMED, `Retrieving ${core_2.formatUtils.pretty(configuration, bundleUrl, core_1.FormatType.PATH)}`);
-                bundleBuffer = await core_2.httpUtils.get(bundleUrl, { configuration });
-            }
-            await setVersion(configuration, null, bundleBuffer, { report });
+            const fetchBuffer = async () => {
+                const filePrefix = `file://`;
+                if (bundleRef.url.startsWith(filePrefix)) {
+                    report.reportInfo(core_1.MessageName.UNNAMED, `Retrieving ${core_2.formatUtils.pretty(configuration, bundleRef.url, core_1.FormatType.PATH)}`);
+                    return await fslib_1.xfs.readFilePromise(bundleRef.url.slice(filePrefix.length));
+                }
+                else {
+                    report.reportInfo(core_1.MessageName.UNNAMED, `Downloading ${core_2.formatUtils.pretty(configuration, bundleRef.url, core_1.FormatType.URL)}`);
+                    return await core_2.httpUtils.get(bundleRef.url, { configuration });
+                }
+            };
+            await setVersion(configuration, bundleRef.version, fetchBuffer, { report, useYarnPath: this.useYarnPath });
         });
         return report.exitCode();
     }
@@ -74,7 +81,9 @@ SetVersionCommand.paths = [
 SetVersionCommand.usage = clipanion_1.Command.Usage({
     description: `lock the Yarn version used by the project`,
     details: `
-      This command will download a specific release of Yarn directly from the Yarn GitHub repository, will store it inside your project, and will change the \`yarnPath\` settings from your project \`.yarnrc.yml\` file to point to the new file.
+      This command will set a specific release of Yarn to be used by Corepack: https://nodejs.org/api/corepack.html.
+
+      By default it only will set the \`packageManager\` field at the root of your project, but if the referenced release cannot be represented this way, if you already have \`yarnPath\` configured, or if you set the \`--yarn-path\` command line flag, then the release will also be downloaded from the Yarn GitHub repository, stored inside your project, and referenced via the \`yarnPath\` settings from your project \`.yarnrc.yml\` file.
 
       A very good use case for this command is to enforce the version of Yarn used by the any single member of your team inside a same project - by doing this you ensure that you have control on Yarn upgrades and downgrades (including on your deployment servers), and get rid of most of the headaches related to someone using a slightly different version and getting a different behavior than you.
 
@@ -138,9 +147,16 @@ async function resolveTag(configuration, request) {
     return data.latest[request];
 }
 exports.resolveTag = resolveTag;
-async function setVersion(configuration, bundleVersion, bundleBuffer, { report }) {
+async function setVersion(configuration, bundleVersion, fetchBuffer, { report, useYarnPath }) {
     var _a;
+    let bundleBuffer;
+    const ensureBuffer = async () => {
+        if (typeof bundleBuffer === `undefined`)
+            bundleBuffer = await fetchBuffer();
+        return bundleBuffer;
+    };
     if (bundleVersion === null) {
+        const bundleBuffer = await ensureBuffer();
         await fslib_1.xfs.mktempPromise(async (tmpDir) => {
             const temporaryPath = fslib_1.ppath.join(tmpDir, `yarn.cjs`);
             await fslib_1.xfs.writeFilePromise(temporaryPath, bundleBuffer);
@@ -158,29 +174,51 @@ async function setVersion(configuration, bundleVersion, bundleBuffer, { report }
     const releaseFolder = fslib_1.ppath.resolve(projectCwd, `.yarn/releases`);
     const absolutePath = fslib_1.ppath.resolve(releaseFolder, `yarn-${bundleVersion}.cjs`);
     const displayPath = fslib_1.ppath.relative(configuration.startingCwd, absolutePath);
-    const projectPath = fslib_1.ppath.relative(projectCwd, absolutePath);
+    const isTaggedYarnVersion = core_2.miscUtils.isTaggedYarnVersion(bundleVersion);
     const yarnPath = configuration.get(`yarnPath`);
-    const updateConfig = yarnPath === null || yarnPath.startsWith(`${releaseFolder}/`);
-    report.reportInfo(core_1.MessageName.UNNAMED, `Saving the new release in ${core_2.formatUtils.pretty(configuration, displayPath, `magenta`)}`);
-    await fslib_1.xfs.removePromise(fslib_1.ppath.dirname(absolutePath));
-    await fslib_1.xfs.mkdirPromise(fslib_1.ppath.dirname(absolutePath), { recursive: true });
-    await fslib_1.xfs.writeFilePromise(absolutePath, bundleBuffer, { mode: 0o755 });
-    if (updateConfig) {
+    const absolutelyMustUseYarnPath = !isTaggedYarnVersion;
+    let probablyShouldUseYarnPath = absolutelyMustUseYarnPath || !!yarnPath || !!useYarnPath;
+    if (useYarnPath === false) {
+        if (absolutelyMustUseYarnPath)
+            throw new core_1.ReportError(core_1.MessageName.UNNAMED, `You explicitly opted out of yarnPath usage in your command line, but the version you specified cannot be represented by Corepack`);
+        probablyShouldUseYarnPath = false;
+    }
+    else if (!probablyShouldUseYarnPath && !process.env.COREPACK_ROOT) {
+        report.reportWarning(core_1.MessageName.UNNAMED, `You don't seem to have ${core_2.formatUtils.applyHyperlink(configuration, `Corepack`, `https://nodejs.org/api/corepack.html`)} enabled; we'll have to rely on ${core_2.formatUtils.applyHyperlink(configuration, `yarnPath`, `https://yarnpkg.com/configuration/yarnrc#yarnPath`)} instead`);
+        probablyShouldUseYarnPath = true;
+    }
+    if (probablyShouldUseYarnPath) {
+        const bundleBuffer = await ensureBuffer();
+        report.reportInfo(core_1.MessageName.UNNAMED, `Saving the new release in ${core_2.formatUtils.pretty(configuration, displayPath, `magenta`)}`);
+        await fslib_1.xfs.removePromise(fslib_1.ppath.dirname(absolutePath));
+        await fslib_1.xfs.mkdirPromise(fslib_1.ppath.dirname(absolutePath), { recursive: true });
+        await fslib_1.xfs.writeFilePromise(absolutePath, bundleBuffer, { mode: 0o755 });
+        if (!yarnPath || fslib_1.ppath.contains(releaseFolder, yarnPath)) {
+            await core_1.Configuration.updateConfiguration(projectCwd, {
+                yarnPath: fslib_1.ppath.relative(projectCwd, absolutePath),
+            });
+        }
+    }
+    else {
+        await fslib_1.xfs.removePromise(fslib_1.ppath.dirname(absolutePath));
         await core_1.Configuration.updateConfiguration(projectCwd, {
-            yarnPath: projectPath,
-        });
-        const manifest = (await core_1.Manifest.tryFind(projectCwd)) || new core_1.Manifest();
-        manifest.packageManager = `yarn@${bundleVersion && core_2.miscUtils.isTaggedYarnVersion(bundleVersion)
-            ? bundleVersion
-            // If the version isn't tagged, we use the latest stable version as the wrapper
-            : await resolveTag(configuration, `stable`)}`;
-        const data = {};
-        manifest.exportTo(data);
-        const path = fslib_1.ppath.join(projectCwd, core_1.Manifest.fileName);
-        const content = `${JSON.stringify(data, null, manifest.indent)}\n`;
-        await fslib_1.xfs.changeFilePromise(path, content, {
-            automaticNewlines: true,
+            yarnPath: core_1.Configuration.deleteProperty,
         });
     }
+    const manifest = (await core_1.Manifest.tryFind(projectCwd)) || new core_1.Manifest();
+    manifest.packageManager = `yarn@${isTaggedYarnVersion
+        ? bundleVersion
+        // If the version isn't tagged, we use the latest stable version as the wrapper
+        : await resolveTag(configuration, `stable`)}`;
+    const data = {};
+    manifest.exportTo(data);
+    const path = fslib_1.ppath.join(projectCwd, core_1.Manifest.fileName);
+    const content = `${JSON.stringify(data, null, manifest.indent)}\n`;
+    await fslib_1.xfs.changeFilePromise(path, content, {
+        automaticNewlines: true,
+    });
+    return {
+        bundleVersion: bundleVersion,
+    };
 }
 exports.setVersion = setVersion;

package/lib/commands/up.d.ts

@@ -6,6 +6,7 @@ export default class UpCommand extends BaseCommand {
     static paths: string[][];
     static usage: Usage;
     interactive: boolean | undefined;
+    fixed: boolean;
     exact: boolean;
     tilde: boolean;
     caret: boolean;

package/lib/commands/up.js

@@ -17,6 +17,9 @@ class UpCommand extends cli_1.BaseCommand {
         this.interactive = clipanion_1.Option.Boolean(`-i,--interactive`, {
             description: `Offer various choices, depending on the detected upgrade paths`,
         });
+        this.fixed = clipanion_1.Option.Boolean(`-F,--fixed`, false, {
+            description: `Store dependency tags as-is instead of resolving them`,
+        });
         this.exact = clipanion_1.Option.Boolean(`-E,--exact`, false, {
             description: `Don't use any semver modifier on the resolved range`,
         });
@@ -90,6 +93,7 @@ class UpCommand extends cli_1.BaseCommand {
         await project.restoreInstallState({
             restoreResolutions: false,
         });
+        const fixed = this.fixed;
         const interactive = (_a = this.interactive) !== null && _a !== void 0 ? _a : configuration.get(`preferInteractive`);
         const modifier = suggestUtils.getModifier(this, project);
         const strategies = interactive ? [
@@ -124,7 +128,7 @@ class UpCommand extends cli_1.BaseCommand {
                                 workspace,
                                 target,
                                 existingDescriptor,
-                                await suggestUtils.getSuggestedDescriptors(request, { project, workspace, cache, target, modifier, strategies }),
+                                await suggestUtils.getSuggestedDescriptors(request, { project, workspace, cache, target, fixed, modifier, strategies }),
                             ];
                         }));
                         isReferenced = true;
@@ -185,7 +189,7 @@ class UpCommand extends cli_1.BaseCommand {
                 ({ answer: selected } = await (0, enquirer_1.prompt)({
                     type: `select`,
                     name: `answer`,
-                    message: `Which range to you want to use in ${core_1.structUtils.prettyWorkspace(configuration, workspace)} ❯ ${target}?`,
+                    message: `Which range do you want to use in ${core_1.structUtils.prettyWorkspace(configuration, workspace)} ❯ ${target}?`,
                     choices: suggestions.map(({ descriptor, name, reason }) => descriptor ? {
                         name,
                         hint: reason,
@@ -219,7 +223,8 @@ class UpCommand extends cli_1.BaseCommand {
             else {
                 const resolver = configuration.makeResolver();
                 const resolveOptions = { project, resolver };
-                const bound = resolver.bindDescriptor(current, workspace.anchoredLocator, resolveOptions);
+                const normalizedDependency = configuration.normalizeDependency(current);
+                const bound = resolver.bindDescriptor(normalizedDependency, workspace.anchoredLocator, resolveOptions);
                 project.forgetResolution(bound);
             }
         }

package/lib/dedupeUtils.d.ts

@@ -1,15 +1,17 @@
 import { Project, ResolveOptions, Resolver, Descriptor, Package, Report, Cache } from '@yarnpkg/core';
 import { Fetcher, FetchOptions } from '@yarnpkg/core';
+export declare type PackageUpdate = {
+    descriptor: Descriptor;
+    currentPackage: Package;
+    updatedPackage: Package;
+    resolvedPackage: Package;
+};
 export declare type Algorithm = (project: Project, patterns: Array<string>, opts: {
     resolver: Resolver;
     resolveOptions: ResolveOptions;
     fetcher: Fetcher;
     fetchOptions: FetchOptions;
-}) => Promise<Array<Promise<{
-    descriptor: Descriptor;
-    currentPackage: Package;
-    updatedPackage: Package;
-} | null>>>;
+}) => Promise<Array<Promise<PackageUpdate>>>;
 export declare enum Strategy {
     /**
      * This strategy dedupes a locator to the best candidate already installed in the project.

package/lib/dedupeUtils.js

@@ -26,44 +26,75 @@ const DEDUPE_ALGORITHMS = {
                 throw new Error(`Assertion failed: The descriptor (${descriptorHash}) should have been registered`);
             core_1.miscUtils.getSetWithDefault(locatorsByIdent, descriptor.identHash).add(locatorHash);
         }
-        return Array.from(project.storedDescriptors.values(), async (descriptor) => {
-            if (patterns.length && !micromatch_1.default.isMatch(core_2.structUtils.stringifyIdent(descriptor), patterns))
-                return null;
+        const deferredMap = new Map(core_1.miscUtils.mapAndFilter(project.storedDescriptors.values(), descriptor => {
+            // We only care about resolutions that are stored in the lockfile
+            // (we shouldn't accidentally try deduping virtual packages)
+            if (core_2.structUtils.isVirtualDescriptor(descriptor))
+                return core_1.miscUtils.mapAndFilter.skip;
+            return [descriptor.descriptorHash, core_1.miscUtils.makeDeferred()];
+        }));
+        for (const descriptor of project.storedDescriptors.values()) {
+            const deferred = deferredMap.get(descriptor.descriptorHash);
+            if (typeof deferred === `undefined`)
+                throw new Error(`Assertion failed: The descriptor (${descriptor.descriptorHash}) should have been registered`);
             const currentResolution = project.storedResolutions.get(descriptor.descriptorHash);
             if (typeof currentResolution === `undefined`)
                 throw new Error(`Assertion failed: The resolution (${descriptor.descriptorHash}) should have been registered`);
-            // We only care about resolutions that are stored in the lockfile
-            // (we shouldn't accidentally try deduping virtual packages)
             const currentPackage = project.originalPackages.get(currentResolution);
             if (typeof currentPackage === `undefined`)
-                return null;
-            // No need to try deduping packages that are not persisted,
-            // they will be resolved again anyways
-            if (!resolver.shouldPersistResolution(currentPackage, resolveOptions))
-                return null;
-            const locators = locatorsByIdent.get(descriptor.identHash);
-            if (typeof locators === `undefined`)
-                throw new Error(`Assertion failed: The resolutions (${descriptor.identHash}) should have been registered`);
-            // No need to choose when there's only one possibility
-            if (locators.size === 1)
-                return null;
-            const references = [...locators].map(locatorHash => {
-                const pkg = project.originalPackages.get(locatorHash);
-                if (typeof pkg === `undefined`)
-                    throw new Error(`Assertion failed: The package (${locatorHash}) should have been registered`);
-                return pkg.reference;
+                throw new Error(`Assertion failed: The package (${currentResolution}) should have been registered`);
+            Promise.resolve().then(async () => {
+                var _a;
+                const dependencies = resolver.getResolutionDependencies(descriptor, resolveOptions);
+                const resolvedDependencies = Object.fromEntries(await core_1.miscUtils.allSettledSafe(Object.entries(dependencies).map(async ([dependencyName, dependency]) => {
+                    const dependencyDeferred = deferredMap.get(dependency.descriptorHash);
+                    if (typeof dependencyDeferred === `undefined`)
+                        throw new Error(`Assertion failed: The descriptor (${dependency.descriptorHash}) should have been registered`);
+                    const dedupeResult = await dependencyDeferred.promise;
+                    if (!dedupeResult)
+                        throw new Error(`Assertion failed: Expected the dependency to have been through the dedupe process itself`);
+                    return [dependencyName, dedupeResult.updatedPackage];
+                })));
+                if (patterns.length && !micromatch_1.default.isMatch(core_2.structUtils.stringifyIdent(descriptor), patterns))
+                    return currentPackage;
+                // No need to try deduping packages that are not persisted,
+                // they will be resolved again anyways
+                if (!resolver.shouldPersistResolution(currentPackage, resolveOptions))
+                    return currentPackage;
+                const candidateHashes = locatorsByIdent.get(descriptor.identHash);
+                if (typeof candidateHashes === `undefined`)
+                    throw new Error(`Assertion failed: The resolutions (${descriptor.identHash}) should have been registered`);
+                // No need to choose when there's only one possibility
+                if (candidateHashes.size === 1)
+                    return currentPackage;
+                const candidates = [...candidateHashes].map(locatorHash => {
+                    const pkg = project.originalPackages.get(locatorHash);
+                    if (typeof pkg === `undefined`)
+                        throw new Error(`Assertion failed: The package (${locatorHash}) should have been registered`);
+                    return pkg;
+                });
+                const satisfying = await resolver.getSatisfying(descriptor, resolvedDependencies, candidates, resolveOptions);
+                const bestLocator = (_a = satisfying.locators) === null || _a === void 0 ? void 0 : _a[0];
+                if (typeof bestLocator === `undefined` || !satisfying.sorted)
+                    return currentPackage;
+                const updatedPackage = project.originalPackages.get(bestLocator.locatorHash);
+                if (typeof updatedPackage === `undefined`)
+                    throw new Error(`Assertion failed: The package (${bestLocator.locatorHash}) should have been registered`);
+                return updatedPackage;
+            }).then(async (updatedPackage) => {
+                const resolvedPackage = await project.preparePackage(updatedPackage, { resolver, resolveOptions });
+                deferred.resolve({
+                    descriptor,
+                    currentPackage,
+                    updatedPackage,
+                    resolvedPackage,
+                });
+            }).catch(error => {
+                deferred.reject(error);
             });
-            const candidates = await resolver.getSatisfying(descriptor, references, resolveOptions);
-            const bestCandidate = candidates === null || candidates === void 0 ? void 0 : candidates[0];
-            if (typeof bestCandidate === `undefined`)
-                return null;
-            const updatedResolution = bestCandidate.locatorHash;
-            const updatedPackage = project.originalPackages.get(updatedResolution);
-            if (typeof updatedPackage === `undefined`)
-                throw new Error(`Assertion failed: The package (${updatedResolution}) should have been registered`);
-            if (updatedResolution === currentResolution)
-                return null;
-            return { descriptor, currentPackage, updatedPackage };
+        }
+        return [...deferredMap.values()].map(deferred => {
+            return deferred.promise;
         });
     },
 };
@@ -97,7 +128,7 @@ async function dedupe(project, { strategy, patterns, cache, report }) {
         let dedupedPackageCount = 0;
         await Promise.all(dedupePromises.map(dedupePromise => dedupePromise
             .then(dedupe => {
-            if (dedupe === null)
+            if (dedupe === null || dedupe.currentPackage.locatorHash === dedupe.updatedPackage.locatorHash)
                 return;
             dedupedPackageCount++;
             const { descriptor, currentPackage, updatedPackage } = dedupe;

package/lib/index.d.ts

@@ -42,6 +42,7 @@ declare module '@yarnpkg/core' {
     interface ConfigurationValueMap {
         enableImmutableInstalls: boolean;
         defaultSemverRangePrefix: `^` | `~` | ``;
+        preferReuse: boolean;
     }
 }
 declare const plugin: Plugin;

package/lib/index.js

@@ -57,6 +57,11 @@ const plugin = {
             values: [`^`, `~`, ``],
             default: suggestUtils.Modifier.CARET,
         },
+        preferReuse: {
+            description: `If true, \`yarn add\` will attempt to reuse the most common dependency range in other workspaces.`,
+            type: core_1.SettingsType.BOOLEAN,
+            default: false,
+        },
     },
     commands: [
         clean_1.default,

package/lib/suggestUtils.d.ts

@@ -78,18 +78,25 @@ export declare function extractDescriptorFromPath(path: PortablePath, { cwd, wor
     cwd: PortablePath;
     workspace: Workspace;
 }): Promise<Descriptor>;
-export declare function getSuggestedDescriptors(request: Descriptor, { project, workspace, cache, target, modifier, strategies, maxResults }: {
+export declare function getSuggestedDescriptors(request: Descriptor, { project, workspace, cache, target, fixed, modifier, strategies, maxResults }: {
     project: Project;
     workspace: Workspace;
     cache: Cache;
     target: Target;
+    fixed: boolean;
     modifier: Modifier;
     strategies: Array<Strategy>;
     maxResults?: number;
 }): Promise<Results>;
-export declare function fetchDescriptorFrom(ident: Ident, range: string, { project, cache, workspace, preserveModifier }: {
+export declare type FetchDescriptorFromOptions = {
     project: Project;
     cache: Cache;
     workspace: Workspace;
+} & ({
     preserveModifier?: boolean | string;
-}): Promise<Descriptor | null>;
+    modifier?: undefined;
+} | {
+    preserveModifier?: undefined;
+    modifier: Modifier;
+});
+export declare function fetchDescriptorFrom(ident: Ident, range: string, { project, cache, workspace, preserveModifier, modifier }: FetchDescriptorFromOptions): Promise<Descriptor | null>;

package/lib/suggestUtils.js

@@ -165,10 +165,15 @@ async function extractDescriptorFromPath(path, { cwd, workspace }) {
     });
 }
 exports.extractDescriptorFromPath = extractDescriptorFromPath;
-async function getSuggestedDescriptors(request, { project, workspace, cache, target, modifier, strategies, maxResults = Infinity }) {
+async function getSuggestedDescriptors(request, { project, workspace, cache, target, fixed, modifier, strategies, maxResults = Infinity }) {
     if (!(maxResults >= 0))
         throw new Error(`Invalid maxResults (${maxResults})`);
-    if (request.range !== `unknown`) {
+    const [requestRange, requestTag] = request.range !== `unknown`
+        ? fixed || semver_1.default.validRange(request.range) || !request.range.match(/^[a-z0-9._-]+$/i)
+            ? [request.range, `latest`]
+            : [`unknown`, request.range]
+        : [`unknown`, `latest`];
+    if (requestRange !== `unknown`) {
         return {
             suggestions: [{
                     descriptor: request,
@@ -265,14 +270,7 @@ async function getSuggestedDescriptors(request, { project, workspace, cache, tar
             case Strategy.LATEST:
                 {
                     await trySuggest(async () => {
-                        if (request.range !== `unknown`) {
-                            suggested.push({
-                                descriptor: request,
-                                name: `Use ${core_2.structUtils.prettyRange(project.configuration, request.range)}`,
-                                reason: `(explicit range requested)`,
-                            });
-                        }
-                        else if (target === Target.PEER) {
+                        if (target === Target.PEER) {
                             suggested.push({
                                 descriptor: core_2.structUtils.makeDescriptor(request, `*`),
                                 name: `Use *`,
@@ -287,9 +285,8 @@ async function getSuggestedDescriptors(request, { project, workspace, cache, tar
                             });
                         }
                         else {
-                            let latest = await fetchDescriptorFrom(request, `latest`, { project, cache, workspace, preserveModifier: false });
+                            const latest = await fetchDescriptorFrom(request, requestTag, { project, cache, workspace, modifier });
                             if (latest) {
-                                latest = applyModifier(latest, modifier);
                                 suggested.push({
                                     descriptor: latest,
                                     name: `Use ${core_2.structUtils.prettyDescriptor(project.configuration, latest)}`,
@@ -308,8 +305,8 @@ async function getSuggestedDescriptors(request, { project, workspace, cache, tar
     };
 }
 exports.getSuggestedDescriptors = getSuggestedDescriptors;
-async function fetchDescriptorFrom(ident, range, { project, cache, workspace, preserveModifier = true }) {
-    const latestDescriptor = core_2.structUtils.makeDescriptor(ident, range);
+async function fetchDescriptorFrom(ident, range, { project, cache, workspace, preserveModifier = true, modifier }) {
+    const latestDescriptor = project.configuration.normalizeDependency(core_2.structUtils.makeDescriptor(ident, range));
     const report = new core_1.ThrowReport();
     const fetcher = project.configuration.makeFetcher();
     const resolver = project.configuration.makeResolver();
@@ -318,7 +315,7 @@ async function fetchDescriptorFrom(ident, range, { project, cache, workspace, pr
     // The descriptor has to be bound for the resolvers that need a parent locator. (e.g. FileResolver)
     // If we didn't bind it, `yarn add ./folder` wouldn't work.
     const boundDescriptor = resolver.bindDescriptor(latestDescriptor, workspace.anchoredLocator, resolveOptions);
-    const candidateLocators = await resolver.getCandidates(boundDescriptor, new Map(), resolveOptions);
+    const candidateLocators = await resolver.getCandidates(boundDescriptor, {}, resolveOptions);
     if (candidateLocators.length === 0)
         return null;
     // Per the requirements exposed in Resolver.ts, the best is the first one
@@ -326,12 +323,32 @@ async function fetchDescriptorFrom(ident, range, { project, cache, workspace, pr
     let { protocol, source, params, selector } = core_2.structUtils.parseRange(core_2.structUtils.convertToManifestRange(bestLocator.reference));
     if (protocol === project.configuration.get(`defaultProtocol`))
         protocol = null;
-    if (semver_1.default.valid(selector) && preserveModifier !== false) {
-        const referenceRange = typeof preserveModifier === `string`
-            ? preserveModifier
-            : latestDescriptor.range;
-        const modifier = extractRangeModifier(referenceRange, { project });
-        selector = modifier + selector;
+    if (semver_1.default.valid(selector)) {
+        const rawSelector = selector;
+        if (typeof modifier !== `undefined`) {
+            selector = modifier + selector;
+        }
+        else if (preserveModifier !== false) {
+            const referenceRange = typeof preserveModifier === `string`
+                ? preserveModifier
+                : latestDescriptor.range;
+            const modifier = extractRangeModifier(referenceRange, { project });
+            selector = modifier + selector;
+        }
+        const screeningDescriptor = core_2.structUtils.makeDescriptor(bestLocator, core_2.structUtils.makeRange({ protocol, source, params, selector }));
+        const screeningLocators = await resolver.getCandidates(project.configuration.normalizeDependency(screeningDescriptor), {}, resolveOptions);
+        // If turning 1.0.0 into ^1.0.0 would cause it to resolve to something else
+        // (for example 1.1.0), then we don't add the modifier.
+        //
+        // This is to account for "weird" release strategies where things like
+        // prereleases are released as older versions than the latest available
+        // ones.
+        //
+        // Ex 1: https://github.com/parcel-bundler/parcel/issues/8010
+        // Ex 2: https://github.com/sveltejs/kit/discussions/4645
+        if (screeningLocators.length !== 1) {
+            selector = rawSelector;
+        }
     }
     return core_2.structUtils.makeDescriptor(bestLocator, core_2.structUtils.makeRange({ protocol, source, params, selector }));
 }

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@yarnpkg/plugin-essentials",
-  "version": "3.2.0",
+  "version": "4.0.0-rc.3",
   "license": "BSD-2-Clause",
   "main": "./lib/index.js",
   "dependencies": {
-    "@yarnpkg/fslib": "^2.6.1",
-    "@yarnpkg/json-proxy": "^2.1.1",
-    "@yarnpkg/parsers": "^2.5.0",
+    "@yarnpkg/fslib": "^3.0.0-rc.3",
+    "@yarnpkg/parsers": "^3.0.0-rc.3",
     "ci-info": "^3.2.0",
-    "clipanion": "^3.2.0-rc.4",
+    "clipanion": "^3.2.0-rc.10",
     "enquirer": "^2.3.6",
     "lodash": "^4.17.15",
     "micromatch": "^4.0.2",
@@ -17,18 +16,17 @@
     "typanion": "^3.3.0"
   },
   "peerDependencies": {
-    "@yarnpkg/cli": "^3.2.0",
-    "@yarnpkg/core": "^3.2.0",
-    "@yarnpkg/plugin-git": "^2.6.0"
+    "@yarnpkg/cli": "^4.0.0-rc.3",
+    "@yarnpkg/core": "^4.0.0-rc.3",
+    "@yarnpkg/plugin-git": "^3.0.0-rc.3"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.136",
     "@types/micromatch": "^4.0.1",
     "@types/semver": "^7.1.0",
-    "@types/treeify": "^1.0.0",
-    "@yarnpkg/cli": "^3.2.0",
-    "@yarnpkg/core": "^3.2.0",
-    "@yarnpkg/plugin-git": "^2.6.0"
+    "@yarnpkg/cli": "^4.0.0-rc.3",
+    "@yarnpkg/core": "^4.0.0-rc.3",
+    "@yarnpkg/plugin-git": "^3.0.0-rc.3"
   },
   "repository": {
     "type": "git",
@@ -47,7 +45,8 @@
     "/lib/**/*"
   ],
   "engines": {
-    "node": ">=12 <14 || 14.2 - 14.9 || >14.10.0"
+    "node": ">=14.15.0"
   },
+  "stableVersion": "3.2.0",
   "typings": "./lib/index.d.ts"
 }