@yarnpkg/plugin-essentials 4.0.0-rc.9 → 4.0.1

package/lib/commands/install.js

@@ -7,7 +7,21 @@ const fslib_1 = require("@yarnpkg/fslib");
 const parsers_1 = require("@yarnpkg/parsers");
 const ci_info_1 = tslib_1.__importDefault(require("ci-info"));
 const clipanion_1 = require("clipanion");
+const semver_1 = tslib_1.__importDefault(require("semver"));
 const t = tslib_1.__importStar(require("typanion"));
+const LOCKFILE_MIGRATION_RULES = [{
+        selector: v => v === -1,
+        name: `nodeLinker`,
+        value: `node-modules`,
+    }, {
+        selector: v => v !== -1 && v < 8,
+        name: `enableGlobalCache`,
+        value: false,
+    }, {
+        selector: v => v !== -1 && v < 8,
+        name: `compressionLevel`,
+        value: `mixed`,
+    }];
 // eslint-disable-next-line arca/no-default-export
 class YarnCommand extends cli_1.BaseCommand {
     constructor() {
@@ -49,7 +63,6 @@ class YarnCommand extends cli_1.BaseCommand {
         this.networkTimeout = clipanion_1.Option.String(`--network-timeout`, { hidden: true });
     }
     async execute() {
-        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 });
@@ -57,113 +70,72 @@ class YarnCommand extends cli_1.BaseCommand {
         // in process of deploying Google Cloud Functions and
         // Google App Engine
         const isGCP = !!process.env.FUNCTION_TARGET || !!process.env.GOOGLE_RUNTIME;
-        const reportDeprecation = async (message, { error }) => {
-            const deprecationReport = await core_1.StreamReport.start({
-                configuration,
-                stdout: this.context.stdout,
-                includeFooter: false,
-            }, async (report) => {
-                if (error) {
-                    report.reportError(core_1.MessageName.DEPRECATED_CLI_SETTINGS, message);
-                }
-                else {
-                    report.reportWarning(core_1.MessageName.DEPRECATED_CLI_SETTINGS, message);
-                }
-            });
-            if (deprecationReport.hasErrors()) {
-                return deprecationReport.exitCode();
-            }
-            else {
-                return null;
-            }
-        };
-        // The ignoreEngines flag isn't implemented at the moment. I'm still
-        // considering how it should work in the context of plugins - would it
-        // make sense to allow them (or direct dependencies) to define new
-        // "engine check"? Since it has implications regarding the architecture,
-        // I prefer to postpone the decision to later. Also it wouldn't be a flag,
-        // it would definitely be a configuration setting.
-        if (typeof this.ignoreEngines !== `undefined`) {
-            const exitCode = await reportDeprecation(`The --ignore-engines option is deprecated; engine checking isn't a core feature anymore`, {
+        const deprecationExitCode = await (0, core_1.reportOptionDeprecations)({
+            configuration,
+            stdout: this.context.stdout,
+        }, [{
+                // The ignoreEngines flag isn't implemented at the moment. I'm still
+                // considering how it should work in the context of plugins - would it
+                // make sense to allow them (or direct dependencies) to define new
+                // "engine check"? Since it has implications regarding the architecture,
+                // I prefer to postpone the decision to later. Also it wouldn't be a flag,
+                // it would definitely be a configuration setting.
+                option: this.ignoreEngines,
+                message: `The --ignore-engines option is deprecated; engine checking isn't a core feature anymore`,
                 error: !ci_info_1.default.VERCEL,
-            });
-            if (exitCode !== null) {
-                return exitCode;
-            }
-        }
-        // The registry flag isn't supported anymore because it makes little sense
-        // to use a registry for a single install. You instead want to configure it
-        // for all installs inside a project, so through the .yarnrc.yml file. Note
-        // that if absolutely necessary, the old behavior can be emulated by adding
-        // the YARN_NPM_REGISTRY_SERVER variable to the environment.
-        if (typeof this.registry !== `undefined`) {
-            const exitCode = await reportDeprecation(`The --registry option is deprecated; prefer setting npmRegistryServer in your .yarnrc.yml file`, {
-                error: false,
-            });
-            if (exitCode !== null) {
-                return exitCode;
-            }
-        }
-        // The preferOffline flag doesn't make much sense with our architecture.
-        // It would require the fetchers to also act as resolvers, which is
-        // doable but quirky. Since a similar behavior is available via the
-        // --cached flag in yarn add, I prefer to move it outside of the core and
-        // let someone implement this "resolver-that-reads-the-cache" logic.
-        if (typeof this.preferOffline !== `undefined`) {
-            const exitCode = await reportDeprecation(`The --prefer-offline flag is deprecated; use the --cached flag with 'yarn add' instead`, {
+            }, {
+                // The registry flag isn't supported anymore because it makes little sense
+                // to use a registry for a single install. You instead want to configure it
+                // for all installs inside a project, so through the .yarnrc.yml file. Note
+                // that if absolutely necessary, the old behavior can be emulated by adding
+                // the YARN_NPM_REGISTRY_SERVER variable to the environment.
+                option: this.registry,
+                message: `The --registry option is deprecated; prefer setting npmRegistryServer in your .yarnrc.yml file`,
+            }, {
+                // The preferOffline flag doesn't make much sense with our architecture.
+                // It would require the fetchers to also act as resolvers, which is
+                // doable but quirky. Since a similar behavior is available via the
+                // --cached flag in yarn add, I prefer to move it outside of the core and
+                // let someone implement this "resolver-that-reads-the-cache" logic.
+                option: this.preferOffline,
+                message: `The --prefer-offline flag is deprecated; use the --cached flag with 'yarn add' instead`,
                 error: !ci_info_1.default.VERCEL,
-            });
-            if (exitCode !== null) {
-                return exitCode;
-            }
-        }
-        // Since the production flag would yield a different lockfile than the
-        // regular installs, it's not part of the regular `install` command anymore.
-        // Instead, we expect users to use it with `yarn workspaces focus` (which can
-        // be used even outside of monorepos).
-        if (typeof this.production !== `undefined`) {
-            const exitCode = await reportDeprecation(`The --production option is deprecated on 'install'; use 'yarn workspaces focus' instead`, {
+            }, {
+                // Since the production flag would yield a different lockfile than the
+                // regular installs, it's not part of the regular `install` command anymore.
+                // Instead, we expect users to use it with `yarn workspaces focus` (which can
+                // be used even outside of monorepos).
+                option: this.production,
+                message: `The --production option is deprecated on 'install'; use 'yarn workspaces focus' instead`,
                 error: true,
-            });
-            if (exitCode !== null) {
-                return exitCode;
-            }
-        }
-        // Yarn 2 isn't interactive during installs anyway, so there's no real point
-        // to this flag at the moment.
-        if (typeof this.nonInteractive !== `undefined`) {
-            const exitCode = await reportDeprecation(`The --non-interactive option is deprecated`, {
+            }, {
+                // Yarn 2+ isn't interactive during installs anyway, so there's no real point
+                // to this flag at the moment.
+                option: this.nonInteractive,
+                message: `The --non-interactive option is deprecated`,
                 error: !isGCP,
-            });
-            if (exitCode !== null) {
-                return exitCode;
-            }
-        }
-        // We want to prevent people from using --frozen-lockfile
-        // Note: it's been deprecated because we're now locking more than just the
-        // lockfile - for example the PnP artifacts will also be locked.
-        if (typeof this.frozenLockfile !== `undefined`) {
-            await reportDeprecation(`The --frozen-lockfile option is deprecated; use --immutable and/or --immutable-cache instead`, {
-                error: false,
-            });
-            this.immutable = this.frozenLockfile;
-        }
-        // We also want to prevent them from using --cache-folder
-        // Note: it's been deprecated because the cache folder should be set from
-        // the settings. Otherwise there would be a very high chance that multiple
-        // Yarn commands would use different caches, causing unexpected behaviors.
-        if (typeof this.cacheFolder !== `undefined`) {
-            const exitCode = await reportDeprecation(`The cache-folder option has been deprecated; use rc settings instead`, {
+            }, {
+                // We want to prevent people from using --frozen-lockfile
+                // Note: it's been deprecated because we're now locking more than just the
+                // lockfile - for example the PnP artifacts will also be locked.
+                option: this.frozenLockfile,
+                message: `The --frozen-lockfile option is deprecated; use --immutable and/or --immutable-cache instead`,
+                callback: () => this.immutable = this.frozenLockfile,
+            }, {
+                // We also want to prevent them from using --cache-folder
+                // Note: it's been deprecated because the cache folder should be set from
+                // the settings. Otherwise there would be a very high chance that multiple
+                // Yarn commands would use different caches, causing unexpected behaviors.
+                option: this.cacheFolder,
+                message: `The cache-folder option has been deprecated; use rc settings instead`,
                 error: !ci_info_1.default.NETLIFY,
-            });
-            if (exitCode !== null) {
-                return exitCode;
-            }
-        }
+            }]);
+        if (deprecationExitCode !== null)
+            return deprecationExitCode;
         const updateMode = this.mode === core_1.InstallMode.UpdateLockfile;
         if (updateMode && (this.immutable || this.immutableCache))
             throw new clipanion_1.UsageError(`${core_1.formatUtils.pretty(configuration, `--immutable`, core_1.formatUtils.Type.CODE)} and ${core_1.formatUtils.pretty(configuration, `--immutable-cache`, core_1.formatUtils.Type.CODE)} cannot be used with ${core_1.formatUtils.pretty(configuration, `--mode=update-lockfile`, core_1.formatUtils.Type.CODE)}`);
-        const immutable = ((_a = this.immutable) !== null && _a !== void 0 ? _a : configuration.get(`enableImmutableInstalls`)) && !updateMode;
+        const immutable = (this.immutable ?? configuration.get(`enableImmutableInstalls`)) && !updateMode;
         const immutableCache = this.immutableCache && !updateMode;
         if (configuration.projectCwd !== null) {
             const fixReport = await core_1.StreamReport.start({
@@ -172,8 +144,16 @@ class YarnCommand extends cli_1.BaseCommand {
                 stdout: this.context.stdout,
                 includeFooter: false,
             }, async (report) => {
+                let changed = false;
+                if (await autofixLegacyPlugins(configuration, immutable)) {
+                    report.reportInfo(core_1.MessageName.AUTOMERGE_SUCCESS, `Automatically removed core plugins that are now builtins 👍`);
+                    changed = true;
+                }
                 if (await autofixMergeConflicts(configuration, immutable)) {
                     report.reportInfo(core_1.MessageName.AUTOMERGE_SUCCESS, `Automatically fixed merge conflicts 👍`);
+                    changed = true;
+                }
+                if (changed) {
                     report.reportSeparator();
                 }
             });
@@ -181,34 +161,6 @@ class YarnCommand extends cli_1.BaseCommand {
                 return fixReport.exitCode();
             }
         }
-        if (configuration.projectCwd !== null && typeof configuration.sources.get(`nodeLinker`) === `undefined`) {
-            const projectCwd = configuration.projectCwd;
-            let content;
-            try {
-                content = await fslib_1.xfs.readFilePromise(fslib_1.ppath.join(projectCwd, fslib_1.Filename.lockfile), `utf8`);
-            }
-            catch { }
-            // If migrating from a v1 install, we automatically enable the node-modules linker,
-            // since that's likely what the author intended to do.
-            if (content === null || content === void 0 ? void 0 : content.includes(`yarn lockfile v1`)) {
-                const nmReport = await core_1.StreamReport.start({
-                    configuration,
-                    json: this.json,
-                    stdout: this.context.stdout,
-                    includeFooter: false,
-                }, async (report) => {
-                    report.reportInfo(core_1.MessageName.AUTO_NM_SUCCESS, `Migrating from Yarn 1; automatically enabling the compatibility node-modules linker 👍`);
-                    report.reportSeparator();
-                    configuration.use(`<compat>`, { nodeLinker: `node-modules` }, projectCwd, { overwrite: true });
-                    await core_1.Configuration.updateConfiguration(projectCwd, {
-                        nodeLinker: `node-modules`,
-                    });
-                });
-                if (nmReport.hasErrors()) {
-                    return nmReport.exitCode();
-                }
-            }
-        }
         if (configuration.projectCwd !== null) {
             const telemetryReport = await core_1.StreamReport.start({
                 configuration,
@@ -216,18 +168,72 @@ class YarnCommand extends cli_1.BaseCommand {
                 stdout: this.context.stdout,
                 includeFooter: false,
             }, async (report) => {
-                var _a;
-                if ((_a = core_1.Configuration.telemetry) === null || _a === void 0 ? void 0 : _a.isNew) {
+                if (core_1.Configuration.telemetry?.isNew) {
+                    core_1.Configuration.telemetry.commitTips();
                     report.reportInfo(core_1.MessageName.TELEMETRY_NOTICE, `Yarn will periodically gather anonymous telemetry: https://yarnpkg.com/advanced/telemetry`);
                     report.reportInfo(core_1.MessageName.TELEMETRY_NOTICE, `Run ${core_1.formatUtils.pretty(configuration, `yarn config set --home enableTelemetry 0`, core_1.formatUtils.Type.CODE)} to disable`);
                     report.reportSeparator();
                 }
+                else if (core_1.Configuration.telemetry?.shouldShowTips) {
+                    const data = await core_1.httpUtils.get(`https://repo.yarnpkg.com/tags`, { configuration, jsonResponse: true }).catch(() => null);
+                    if (data !== null) {
+                        let newVersion = null;
+                        if (core_1.YarnVersion !== null) {
+                            const isRcBinary = semver_1.default.prerelease(core_1.YarnVersion);
+                            const releaseType = isRcBinary ? `canary` : `stable`;
+                            const candidate = data.latest[releaseType];
+                            if (semver_1.default.gt(candidate, core_1.YarnVersion)) {
+                                newVersion = [releaseType, candidate];
+                            }
+                        }
+                        if (newVersion) {
+                            core_1.Configuration.telemetry.commitTips();
+                            report.reportInfo(core_1.MessageName.VERSION_NOTICE, `${core_1.formatUtils.applyStyle(configuration, `A new ${newVersion[0]} version of Yarn is available:`, core_1.formatUtils.Style.BOLD)} ${core_1.structUtils.prettyReference(configuration, newVersion[1])}!`);
+                            report.reportInfo(core_1.MessageName.VERSION_NOTICE, `Upgrade now by running ${core_1.formatUtils.pretty(configuration, `yarn set version ${newVersion[1]}`, core_1.formatUtils.Type.CODE)}`);
+                            report.reportSeparator();
+                        }
+                        else {
+                            const tip = core_1.Configuration.telemetry.selectTip(data.tips);
+                            if (tip) {
+                                report.reportInfo(core_1.MessageName.TIPS_NOTICE, core_1.formatUtils.pretty(configuration, tip.message, core_1.formatUtils.Type.MARKDOWN_INLINE));
+                                if (tip.url)
+                                    report.reportInfo(core_1.MessageName.TIPS_NOTICE, `Learn more at ${tip.url}`);
+                                report.reportSeparator();
+                            }
+                        }
+                    }
+                }
             });
             if (telemetryReport.hasErrors()) {
                 return telemetryReport.exitCode();
             }
         }
         const { project, workspace } = await core_1.Project.find(configuration, this.context.cwd);
+        const lockfileLastVersion = project.lockfileLastVersion;
+        if (lockfileLastVersion !== null) {
+            const compatReport = await core_1.StreamReport.start({
+                configuration,
+                json: this.json,
+                stdout: this.context.stdout,
+                includeFooter: false,
+            }, async (report) => {
+                const newSettings = {};
+                for (const rule of LOCKFILE_MIGRATION_RULES) {
+                    if (rule.selector(lockfileLastVersion) && typeof configuration.sources.get(rule.name) === `undefined`) {
+                        configuration.use(`<compat>`, { [rule.name]: rule.value }, project.cwd, { overwrite: true });
+                        newSettings[rule.name] = rule.value;
+                    }
+                }
+                if (Object.keys(newSettings).length > 0) {
+                    await core_1.Configuration.updateConfiguration(project.cwd, newSettings);
+                    report.reportInfo(core_1.MessageName.MIGRATION_SUCCESS, `Migrated your project to the latest Yarn version 🚀`);
+                    report.reportSeparator();
+                }
+            });
+            if (compatReport.hasErrors()) {
+                return compatReport.exitCode();
+            }
+        }
         const cache = await core_1.Cache.find(configuration, { immutable: immutableCache, check: this.checkCache });
         if (!workspace)
             throw new cli_1.WorkspaceRequiredError(project.cwd, this.context.cwd);
@@ -235,9 +241,9 @@ class YarnCommand extends cli_1.BaseCommand {
             restoreResolutions: false,
         });
         const enableHardenedMode = configuration.get(`enableHardenedMode`);
-        if ((_b = this.refreshLockfile) !== null && _b !== void 0 ? _b : enableHardenedMode)
+        if (this.refreshLockfile ?? enableHardenedMode)
             project.lockfileNeedsRefresh = true;
-        const checkResolutions = (_c = this.checkResolutions) !== null && _c !== void 0 ? _c : enableHardenedMode;
+        const checkResolutions = this.checkResolutions ?? 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.
@@ -245,18 +251,17 @@ class YarnCommand extends cli_1.BaseCommand {
         // install logic should be implemented elsewhere (probably in either of
         // the Configuration and Install classes). Feel free to open an issue
         // in order to ask for design feedback before writing features.
-        const report = await core_1.StreamReport.start({
-            configuration,
+        return await project.installWithNewReport({
             json: this.json,
             stdout: this.context.stdout,
-            includeLogs: true,
-        }, async (report) => {
-            await project.install({ cache, report, immutable, checkResolutions, mode: this.mode });
+        }, {
+            cache,
+            immutable,
+            checkResolutions,
+            mode: this.mode,
         });
-        return report.exitCode();
     }
 }
-exports.default = YarnCommand;
 YarnCommand.paths = [
     [`install`],
     clipanion_1.Command.Default,
@@ -288,7 +293,7 @@ YarnCommand.usage = clipanion_1.Command.Usage({
 
       If the \`--mode=<mode>\` option is set, Yarn will change which artifacts are generated. The modes currently supported are:
 
-      - \`skip-build\` will not run the build scripts at all. Note that this is different from setting \`enableScripts\` to false because the later will disable build scripts, and thus affect the content of the artifacts generated on disk, whereas the former will just disable the build step - but not the scripts themselves, which just won't run.
+      - \`skip-build\` will not run the build scripts at all. Note that this is different from setting \`enableScripts\` to false because the latter will disable build scripts, and thus affect the content of the artifacts generated on disk, whereas the former will just disable the build step - but not the scripts themselves, which just won't run.
 
       - \`update-lockfile\` will skip the link step altogether, and only fetch packages that are missing from the lockfile (or that have no associated checksums). This mode is typically used by tools like Renovate or Dependabot to keep a lockfile up-to-date without incurring the full install cost.
     `,
@@ -303,14 +308,12 @@ YarnCommand.usage = clipanion_1.Command.Usage({
             `$0 install --immutable --immutable-cache --check-cache`,
         ]],
 });
-const MERGE_CONFLICT_ANCESTOR = `|||||||`;
-const MERGE_CONFLICT_END = `>>>>>>>`;
-const MERGE_CONFLICT_SEP = `=======`;
+exports.default = YarnCommand;
 const MERGE_CONFLICT_START = `<<<<<<<`;
 async function autofixMergeConflicts(configuration, immutable) {
     if (!configuration.projectCwd)
         return false;
-    const lockfilePath = fslib_1.ppath.join(configuration.projectCwd, configuration.get(`lockfileFilename`));
+    const lockfilePath = fslib_1.ppath.join(configuration.projectCwd, fslib_1.Filename.lockfile);
     if (!await fslib_1.xfs.existsPromise(lockfilePath))
         return false;
     const file = await fslib_1.xfs.readFilePromise(lockfilePath, `utf8`);
@@ -318,22 +321,74 @@ async function autofixMergeConflicts(configuration, immutable) {
         return false;
     if (immutable)
         throw new core_1.ReportError(core_1.MessageName.AUTOMERGE_IMMUTABLE, `Cannot autofix a lockfile when running an immutable install`);
-    const [left, right] = getVariants(file);
-    let parsedLeft;
-    let parsedRight;
-    try {
-        parsedLeft = (0, parsers_1.parseSyml)(left);
-        parsedRight = (0, parsers_1.parseSyml)(right);
+    let commits = await core_1.execUtils.execvp(`git`, [`rev-parse`, `MERGE_HEAD`, `HEAD`], {
+        cwd: configuration.projectCwd,
+    });
+    if (commits.code !== 0) {
+        commits = await core_1.execUtils.execvp(`git`, [`rev-parse`, `REBASE_HEAD`, `HEAD`], {
+            cwd: configuration.projectCwd,
+        });
     }
-    catch (error) {
-        throw new core_1.ReportError(core_1.MessageName.AUTOMERGE_FAILED_TO_PARSE, `The individual variants of the lockfile failed to parse`);
+    if (commits.code !== 0) {
+        commits = await core_1.execUtils.execvp(`git`, [`rev-parse`, `CHERRY_PICK_HEAD`, `HEAD`], {
+            cwd: configuration.projectCwd,
+        });
     }
-    const merged = {
-        ...parsedLeft,
-        ...parsedRight,
-    };
+    if (commits.code !== 0)
+        throw new core_1.ReportError(core_1.MessageName.AUTOMERGE_GIT_ERROR, `Git returned an error when trying to find the commits pertaining to the conflict`);
+    let variants = await Promise.all(commits.stdout.trim().split(/\n/).map(async (hash) => {
+        const content = await core_1.execUtils.execvp(`git`, [`show`, `${hash}:./${fslib_1.Filename.lockfile}`], {
+            cwd: configuration.projectCwd,
+        });
+        if (content.code !== 0)
+            throw new core_1.ReportError(core_1.MessageName.AUTOMERGE_GIT_ERROR, `Git returned an error when trying to access the lockfile content in ${hash}`);
+        try {
+            return (0, parsers_1.parseSyml)(content.stdout);
+        }
+        catch {
+            throw new core_1.ReportError(core_1.MessageName.AUTOMERGE_FAILED_TO_PARSE, `A variant of the conflicting lockfile failed to parse`);
+        }
+    }));
     // Old-style lockfiles should be filtered out (for example when switching
-    // from a Yarn 2 branch to a Yarn 1 branch). Fortunately (?), they actually
+    // from a Yarn 2 branch to a Yarn 1 branch).
+    variants = variants.filter(variant => {
+        return !!variant.__metadata;
+    });
+    for (const variant of variants) {
+        // Pre-lockfile v7, the entries weren't normalized (ie we had "foo@x.y.z"
+        // in the lockfile rather than "foo@npm:x.y.z")
+        if (variant.__metadata.version < 7) {
+            for (const key of Object.keys(variant)) {
+                if (key === `__metadata`)
+                    continue;
+                const descriptor = core_1.structUtils.parseDescriptor(key, true);
+                const normalizedDescriptor = configuration.normalizeDependency(descriptor);
+                const newKey = core_1.structUtils.stringifyDescriptor(normalizedDescriptor);
+                if (newKey !== key) {
+                    variant[newKey] = variant[key];
+                    delete variant[key];
+                }
+            }
+        }
+        // We encode the cacheKeys inside the checksums so that the reconciliation
+        // can merge the data together
+        for (const key of Object.keys(variant)) {
+            if (key === `__metadata`)
+                continue;
+            const checksum = variant[key].checksum;
+            if (typeof checksum === `string` && checksum.includes(`/`))
+                continue;
+            variant[key].checksum = `${variant.__metadata.cacheKey}/${checksum}`;
+        }
+    }
+    const merged = Object.assign({}, ...variants);
+    // We must keep the lockfile version as small as necessary to force Yarn to
+    // refresh the merged-in lockfile metadata that may be missing.
+    merged.__metadata.version = `${Math.min(...variants.map(variant => {
+        return parseInt(variant.__metadata.version ?? 0);
+    }))}`;
+    // It shouldn't matter, since the cacheKey have been embed within the checksums
+    merged.__metadata.cacheKey = `merged`;
     // parse as valid YAML except that the objects become strings. We can use
     // that to detect them. Damn, it's really ugly though.
     for (const [key, value] of Object.entries(merged))
@@ -344,52 +399,37 @@ async function autofixMergeConflicts(configuration, immutable) {
     });
     return true;
 }
-function getVariants(file) {
-    const variants = [[], []];
-    const lines = file.split(/\r?\n/g);
-    let skip = false;
-    while (lines.length > 0) {
-        const line = lines.shift();
-        if (typeof line === `undefined`)
-            throw new Error(`Assertion failed: Some lines should remain`);
-        if (line.startsWith(MERGE_CONFLICT_START)) {
-            // get the first variant
-            while (lines.length > 0) {
-                const conflictLine = lines.shift();
-                if (typeof conflictLine === `undefined`)
-                    throw new Error(`Assertion failed: Some lines should remain`);
-                if (conflictLine === MERGE_CONFLICT_SEP) {
-                    skip = false;
-                    break;
-                }
-                else if (skip || conflictLine.startsWith(MERGE_CONFLICT_ANCESTOR)) {
-                    skip = true;
-                    continue;
-                }
-                else {
-                    variants[0].push(conflictLine);
-                }
-            }
-            // get the second variant
-            while (lines.length > 0) {
-                const conflictLine = lines.shift();
-                if (typeof conflictLine === `undefined`)
-                    throw new Error(`Assertion failed: Some lines should remain`);
-                if (conflictLine.startsWith(MERGE_CONFLICT_END)) {
-                    break;
-                }
-                else {
-                    variants[1].push(conflictLine);
-                }
-            }
-        }
-        else {
-            variants[0].push(line);
-            variants[1].push(line);
-        }
-    }
-    return [
-        variants[0].join(`\n`),
-        variants[1].join(`\n`),
-    ];
+async function autofixLegacyPlugins(configuration, immutable) {
+    if (!configuration.projectCwd)
+        return false;
+    const legacyPlugins = [];
+    const yarnPluginDir = fslib_1.ppath.join(configuration.projectCwd, `.yarn/plugins/@yarnpkg`);
+    const changed = await core_1.Configuration.updateConfiguration(configuration.projectCwd, {
+        plugins: plugins => {
+            if (!Array.isArray(plugins))
+                return plugins;
+            const filteredPlugins = plugins.filter((plugin) => {
+                if (!plugin.path)
+                    return true;
+                const resolvedPath = fslib_1.ppath.resolve(configuration.projectCwd, plugin.path);
+                const isLegacy = core_1.LEGACY_PLUGINS.has(plugin.spec) && fslib_1.ppath.contains(yarnPluginDir, resolvedPath);
+                if (isLegacy)
+                    legacyPlugins.push(resolvedPath);
+                return !isLegacy;
+            });
+            if (filteredPlugins.length === 0)
+                return core_1.Configuration.deleteProperty;
+            if (filteredPlugins.length === plugins.length)
+                return plugins;
+            return filteredPlugins;
+        },
+    }, {
+        immutable,
+    });
+    if (!changed)
+        return false;
+    await Promise.all(legacyPlugins.map(async (pluginPath) => {
+        await fslib_1.xfs.removePromise(pluginPath);
+    }));
+    return true;
 }

package/lib/commands/link.d.ts

@@ -6,6 +6,6 @@ export default class LinkCommand extends BaseCommand {
     all: boolean;
     private: boolean;
     relative: boolean;
-    destination: string;
-    execute(): Promise<1 | 0>;
+    destinations: string[];
+    execute(): Promise<0 | 1>;
 }