@pnpm/installing.commands 1004.6.10

package/lib/recursive.js

@@ -0,0 +1,406 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { rebuild } from '@pnpm/building.commands';
+import { throwOnCommandFail, } from '@pnpm/cli.utils';
+import { createMatcherWithIndex } from '@pnpm/config.matcher';
+import { createProjectConfigRecord, getWorkspaceConcurrency, } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { requireHooks } from '@pnpm/hooks.pnpmfile';
+import { arrayOfWorkspacePackagesToMap } from '@pnpm/installing.context';
+import { addDependenciesToPackage, IgnoredBuildsError, install, mutateModules, } from '@pnpm/installing.deps-installer';
+import { logger } from '@pnpm/logger';
+import { filterDependenciesByType } from '@pnpm/pkg-manifest.utils';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { sortProjects } from '@pnpm/workspace.projects-sorter';
+import { updateWorkspaceManifest } from '@pnpm/workspace.workspace-manifest-writer';
+import { isSubdir } from 'is-subdir';
+import pFilter from 'p-filter';
+import pLimit from 'p-limit';
+import { getPinnedVersion } from './getPinnedVersion.js';
+import { getSaveType } from './getSaveType.js';
+import { createWorkspaceSpecs, updateToWorkspacePackagesFromManifest } from './updateWorkspaceDependencies.js';
+export async function recursive(allProjects, params, opts, cmdFullName) {
+    if (allProjects.length === 0) {
+        // It might make sense to throw an exception in this case
+        return false;
+    }
+    const pkgs = Object.values(opts.selectedProjectsGraph).map((wsPkg) => wsPkg.package);
+    if (pkgs.length === 0) {
+        return false;
+    }
+    const manifestsByPath = getManifestsByPath(allProjects);
+    const throwOnFail = throwOnCommandFail.bind(null, `pnpm recursive ${cmdFullName}`);
+    const store = opts.storeControllerAndDir ?? await createStoreController(opts);
+    const workspacePackages = arrayOfWorkspacePackagesToMap(allProjects);
+    const targetDependenciesField = getSaveType(opts);
+    const installOpts = Object.assign(opts, {
+        allProjects: getAllProjects(manifestsByPath, opts.allProjectsGraph, opts.sort),
+        linkWorkspacePackagesDepth: opts.linkWorkspacePackages === 'deep' ? Infinity : opts.linkWorkspacePackages ? 0 : -1,
+        ownLifecycleHooksStdio: 'pipe',
+        peer: opts.savePeer,
+        pruneLockfileImporters: opts.pruneLockfileImporters ??
+            (((opts.ignoredPackages == null) || opts.ignoredPackages.size === 0) &&
+                pkgs.length === allProjects.length),
+        saveCatalogName: opts.saveCatalogName,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+        targetDependenciesField,
+        workspacePackages,
+        forceHoistPattern: typeof opts.rawLocalConfig?.['hoist-pattern'] !== 'undefined' || typeof opts.rawLocalConfig?.['hoist'] !== 'undefined',
+        forceShamefullyHoist: typeof opts.rawLocalConfig?.['shamefully-hoist'] !== 'undefined',
+    });
+    const result = {};
+    const projectConfigRecord = createProjectConfigRecord(opts);
+    const getProjectConfig = projectConfigRecord
+        ? manifest => manifest.name ? projectConfigRecord[manifest.name] : undefined
+        : () => undefined;
+    const updateToLatest = opts.update && opts.latest;
+    const includeDirect = opts.includeDirect ?? {
+        dependencies: true,
+        devDependencies: true,
+        optionalDependencies: true,
+    };
+    let updateMatch;
+    if (cmdFullName === 'update') {
+        if (params.length === 0) {
+            const ignoreDeps = opts.updateConfig?.ignoreDependencies;
+            if (ignoreDeps?.length) {
+                params = makeIgnorePatterns(ignoreDeps);
+            }
+        }
+        updateMatch = params.length ? createMatcher(params) : null;
+    }
+    else {
+        updateMatch = null;
+    }
+    // For a workspace with shared lockfile
+    if (opts.lockfileDir && ['add', 'install', 'remove', 'update', 'import'].includes(cmdFullName)) {
+        let importers = getImporters(opts);
+        const calculatedRepositoryRoot = await fs.realpath(calculateRepositoryRoot(opts.workspaceDir, importers.map(x => x.rootDir)));
+        const isFromWorkspace = isSubdir.bind(null, calculatedRepositoryRoot);
+        importers = await pFilter(importers, async ({ rootDirRealPath }) => isFromWorkspace(rootDirRealPath));
+        if (importers.length === 0)
+            return true;
+        let mutation;
+        switch (cmdFullName) {
+            case 'remove':
+                mutation = 'uninstallSome';
+                break;
+            case 'import':
+                mutation = 'install';
+                break;
+            default:
+                mutation = (params.length === 0 && !updateToLatest ? 'install' : 'installSome');
+                break;
+        }
+        const mutatedImporters = [];
+        await Promise.all(importers.map(async ({ rootDir }) => {
+            const { manifest } = manifestsByPath[rootDir];
+            const localConfig = getProjectConfig(manifest) ?? {};
+            const modulesDir = localConfig.modulesDir ?? opts.modulesDir;
+            let currentInput = [...params];
+            if (updateMatch != null) {
+                currentInput = matchDependencies(updateMatch, manifest, includeDirect);
+                if ((currentInput.length === 0) && (typeof opts.depth === 'undefined' || opts.depth <= 0)) {
+                    installOpts.pruneLockfileImporters = false;
+                    return;
+                }
+            }
+            if (updateToLatest && (!params || (params.length === 0))) {
+                currentInput = Object.keys(filterDependenciesByType(manifest, includeDirect));
+            }
+            if (opts.workspace) {
+                if (!currentInput || (currentInput.length === 0)) {
+                    currentInput = updateToWorkspacePackagesFromManifest(manifest, includeDirect, workspacePackages);
+                }
+                else {
+                    currentInput = createWorkspaceSpecs(currentInput, workspacePackages);
+                }
+            }
+            switch (mutation) {
+                case 'uninstallSome':
+                    mutatedImporters.push({
+                        dependencyNames: currentInput,
+                        modulesDir,
+                        mutation,
+                        rootDir,
+                        targetDependenciesField,
+                    });
+                    return;
+                case 'installSome':
+                    mutatedImporters.push({
+                        allowNew: cmdFullName === 'install' || cmdFullName === 'add',
+                        dependencySelectors: currentInput,
+                        modulesDir,
+                        mutation,
+                        peer: opts.savePeer,
+                        pinnedVersion: getPinnedVersion({
+                            saveExact: typeof localConfig.saveExact === 'boolean' ? localConfig.saveExact : opts.saveExact,
+                            savePrefix: typeof localConfig.savePrefix === 'string' ? localConfig.savePrefix : opts.savePrefix,
+                        }),
+                        rootDir,
+                        targetDependenciesField,
+                        update: opts.update,
+                        updateMatching: opts.updateMatching,
+                        updatePackageManifest: opts.updatePackageManifest,
+                        updateToLatest: opts.latest,
+                    });
+                    return;
+                case 'install':
+                    mutatedImporters.push({
+                        modulesDir,
+                        mutation,
+                        pruneDirectDependencies: opts.pruneDirectDependencies,
+                        rootDir,
+                        update: opts.update,
+                        updateMatching: opts.updateMatching,
+                        updatePackageManifest: opts.updatePackageManifest,
+                        updateToLatest: opts.latest,
+                    });
+            }
+        }));
+        if (!opts.selectedProjectsGraph[opts.workspaceDir] && manifestsByPath[opts.workspaceDir] != null) {
+            mutatedImporters.push({
+                mutation: 'install',
+                rootDir: opts.workspaceDir,
+            });
+        }
+        if ((mutatedImporters.length === 0) && cmdFullName === 'update' && opts.depth === 0) {
+            throw new PnpmError('NO_PACKAGE_IN_DEPENDENCIES', 'None of the specified packages were found in the dependencies of any of the projects.');
+        }
+        const { updatedCatalogs, updatedProjects: mutatedPkgs, ignoredBuilds, } = await mutateModules(mutatedImporters, {
+            ...installOpts,
+            storeController: store.ctrl,
+        });
+        if (opts.save !== false) {
+            const promises = mutatedPkgs.map(async ({ originalManifest, manifest, rootDir }) => {
+                return manifestsByPath[rootDir].writeProjectManifest(originalManifest ?? manifest);
+            });
+            promises.push(updateWorkspaceManifest(opts.workspaceDir, {
+                updatedCatalogs,
+                cleanupUnusedCatalogs: opts.cleanupUnusedCatalogs,
+                allProjects,
+            }));
+            await Promise.all(promises);
+        }
+        if (opts.strictDepBuilds && ignoredBuilds?.size) {
+            throw new IgnoredBuildsError(ignoredBuilds);
+        }
+        return true;
+    }
+    const pkgPaths = Object.keys(opts.selectedProjectsGraph).sort();
+    let updatedCatalogs;
+    const limitInstallation = pLimit(getWorkspaceConcurrency(opts.workspaceConcurrency));
+    await Promise.all(pkgPaths.map(async (rootDir) => limitInstallation(async () => {
+        const hooks = opts.ignorePnpmfile
+            ? {}
+            : await (async () => {
+                const { hooks: pnpmfileHooks } = await requireHooks(rootDir, opts);
+                return {
+                    ...opts.hooks,
+                    ...pnpmfileHooks,
+                    afterAllResolved: [...(pnpmfileHooks.afterAllResolved ?? []), ...(opts.hooks?.afterAllResolved ?? [])],
+                    readPackage: [...(pnpmfileHooks.readPackage ?? []), ...(opts.hooks?.readPackage ?? [])],
+                };
+            })();
+        try {
+            if (opts.ignoredPackages?.has(rootDir)) {
+                return;
+            }
+            result[rootDir] = { status: 'running' };
+            const { manifest, writeProjectManifest } = manifestsByPath[rootDir];
+            let currentInput = [...params];
+            if (updateMatch != null) {
+                currentInput = matchDependencies(updateMatch, manifest, includeDirect);
+                if (currentInput.length === 0)
+                    return;
+            }
+            if (updateToLatest && (!params || (params.length === 0))) {
+                currentInput = Object.keys(filterDependenciesByType(manifest, includeDirect));
+            }
+            if (opts.workspace) {
+                if (!currentInput || (currentInput.length === 0)) {
+                    currentInput = updateToWorkspacePackagesFromManifest(manifest, includeDirect, workspacePackages);
+                }
+                else {
+                    currentInput = createWorkspaceSpecs(currentInput, workspacePackages);
+                }
+            }
+            let action;
+            switch (cmdFullName) {
+                case 'remove':
+                    action = async (manifest, opts) => {
+                        const mutationResult = await mutateModules([
+                            {
+                                dependencyNames: currentInput,
+                                mutation: 'uninstallSome',
+                                rootDir,
+                            },
+                        ], opts);
+                        return {
+                            updatedCatalogs: undefined, // there's no reason to add new or update catalogs on `pnpm remove`
+                            updatedManifest: mutationResult.updatedProjects[0].manifest,
+                            ignoredBuilds: mutationResult.ignoredBuilds,
+                        };
+                    };
+                    break;
+                default:
+                    action = currentInput.length === 0
+                        ? install
+                        : async (manifest, opts) => addDependenciesToPackage(manifest, currentInput, opts);
+                    break;
+            }
+            const localConfig = getProjectConfig(manifest) ?? {};
+            const { updatedCatalogs: newCatalogsAddition, updatedManifest: newManifest, ignoredBuilds, } = await action(manifest, {
+                ...installOpts,
+                ...localConfig,
+                ...opts.allProjectsGraph[rootDir]?.package,
+                bin: path.join(rootDir, 'node_modules', '.bin'),
+                dir: rootDir,
+                hooks,
+                ignoreScripts: true,
+                pinnedVersion: getPinnedVersion({
+                    saveExact: typeof localConfig.saveExact === 'boolean' ? localConfig.saveExact : opts.saveExact,
+                    savePrefix: typeof localConfig.savePrefix === 'string' ? localConfig.savePrefix : opts.savePrefix,
+                }),
+                rawConfig: {
+                    ...installOpts.rawConfig,
+                    ...localConfig,
+                },
+                storeController: store.ctrl,
+            });
+            if (opts.save !== false) {
+                await writeProjectManifest(newManifest);
+                if (newCatalogsAddition) {
+                    updatedCatalogs ??= {};
+                    Object.assign(updatedCatalogs, newCatalogsAddition);
+                }
+            }
+            if (opts.strictDepBuilds && ignoredBuilds?.size) {
+                throw new IgnoredBuildsError(ignoredBuilds);
+            }
+            result[rootDir].status = 'passed';
+        }
+        catch (err) { // eslint-disable-line
+            logger.info(err);
+            if (!opts.bail) {
+                result[rootDir] = {
+                    status: 'failure',
+                    error: err,
+                    message: err.message,
+                    prefix: rootDir,
+                };
+                return;
+            }
+            err['prefix'] = rootDir;
+            throw err;
+        }
+    })));
+    await updateWorkspaceManifest(opts.workspaceDir, {
+        updatedCatalogs,
+        cleanupUnusedCatalogs: opts.cleanupUnusedCatalogs,
+        allProjects,
+    });
+    if (!opts.lockfileOnly && !opts.ignoreScripts && (cmdFullName === 'add' ||
+        cmdFullName === 'install' ||
+        cmdFullName === 'update')) {
+        await rebuild.handler({
+            ...opts,
+            pending: opts.pending === true,
+            skipIfHasSideEffectsCache: true,
+        }, []);
+    }
+    throwOnFail(result);
+    if (!Object.values(result).filter(({ status }) => status === 'passed').length && cmdFullName === 'update' && opts.depth === 0) {
+        throw new PnpmError('NO_PACKAGE_IN_DEPENDENCIES', 'None of the specified packages were found in the dependencies of any of the projects.');
+    }
+    return true;
+}
+function calculateRepositoryRoot(workspaceDir, projectDirs) {
+    // assume repo root is workspace dir
+    let relativeRepoRoot = '.';
+    for (const rootDir of projectDirs) {
+        const relativePartRegExp = new RegExp(`^(\\.\\.\\${path.sep})+`);
+        const relativePartMatch = relativePartRegExp.exec(path.relative(workspaceDir, rootDir));
+        if (relativePartMatch != null) {
+            const relativePart = relativePartMatch[0];
+            if (relativePart.length > relativeRepoRoot.length) {
+                relativeRepoRoot = relativePart;
+            }
+        }
+    }
+    return path.resolve(workspaceDir, relativeRepoRoot);
+}
+export function matchDependencies(match, manifest, include) {
+    const deps = Object.keys(filterDependenciesByType(manifest, include));
+    const matchedDeps = [];
+    for (const dep of deps) {
+        const spec = match(dep);
+        if (spec === null)
+            continue;
+        matchedDeps.push(spec ? `${dep}@${spec}` : dep);
+    }
+    return matchedDeps;
+}
+export function createMatcher(params) {
+    const patterns = [];
+    const specs = [];
+    for (const param of params) {
+        const { pattern, versionSpec } = parseUpdateParam(param);
+        patterns.push(pattern);
+        specs.push(versionSpec ?? '');
+    }
+    const matcher = createMatcherWithIndex(patterns);
+    return (depName) => {
+        const index = matcher(depName);
+        if (index === -1)
+            return null;
+        return specs[index];
+    };
+}
+export function parseUpdateParam(param) {
+    const atIndex = param.indexOf('@', param[0] === '!' ? 2 : 1);
+    if (atIndex === -1) {
+        return {
+            pattern: param,
+            versionSpec: undefined,
+        };
+    }
+    return {
+        pattern: param.slice(0, atIndex),
+        versionSpec: param.slice(atIndex + 1),
+    };
+}
+export function makeIgnorePatterns(ignoredDependencies) {
+    return ignoredDependencies.map(depName => `!${depName}`);
+}
+function getAllProjects(manifestsByPath, allProjectsGraph, sort) {
+    const chunks = sort !== false
+        ? sortProjects(allProjectsGraph)
+        : [Object.keys(allProjectsGraph).sort()];
+    return chunks.map((prefixes, buildIndex) => prefixes.map((rootDir) => {
+        const { rootDirRealPath, modulesDir } = allProjectsGraph[rootDir].package;
+        return {
+            buildIndex,
+            manifest: manifestsByPath[rootDir].manifest,
+            rootDir,
+            rootDirRealPath,
+            modulesDir,
+        };
+    })).flat();
+}
+function getManifestsByPath(projects) {
+    const manifestsByPath = {};
+    for (const { rootDir, manifest, writeProjectManifest } of projects) {
+        manifestsByPath[rootDir] = { manifest, writeProjectManifest };
+    }
+    return manifestsByPath;
+}
+function getImporters(opts) {
+    let rootDirs = Object.keys(opts.selectedProjectsGraph);
+    if (opts.ignoredPackages != null) {
+        rootDirs = rootDirs.filter((rootDir) => !opts.ignoredPackages.has(rootDir));
+    }
+    return rootDirs.map((rootDir) => ({ rootDir, rootDirRealPath: opts.selectedProjectsGraph[rootDir].package.rootDirRealPath }));
+}
+//# sourceMappingURL=recursive.js.map

package/lib/remove.d.ts

@@ -0,0 +1,12 @@
+import type { CompletionFunc } from '@pnpm/cli.command';
+import { type Config } from '@pnpm/config.reader';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare function help(): string;
+export declare const commandNames: string[];
+export declare const completion: CompletionFunc;
+export declare function handler(opts: CreateStoreControllerOptions & Pick<Config, 'allProjects' | 'allProjectsGraph' | 'bail' | 'bin' | 'configDependencies' | 'dev' | 'engineStrict' | 'globalPnpmfile' | 'hooks' | 'ignorePnpmfile' | 'linkWorkspacePackages' | 'lockfileDir' | 'optional' | 'production' | 'rawLocalConfig' | 'registries' | 'rootProjectManifest' | 'rootProjectManifestDir' | 'saveDev' | 'saveOptional' | 'saveProd' | 'selectedProjectsGraph' | 'workspaceDir' | 'workspacePackagePatterns' | 'sharedWorkspaceLockfile' | 'cleanupUnusedCatalogs'> & {
+    recursive?: boolean;
+    pnpmfile: string[];
+} & Partial<Pick<Config, 'global' | 'globalPkgDir'>>, params: string[]): Promise<void>;

package/lib/remove.js

@@ -0,0 +1,189 @@
+import { FILTERING, OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl, readDepNameCompletions, readProjectManifest, } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { handleGlobalRemove } from '@pnpm/global.commands';
+import { arrayOfWorkspacePackagesToMap } from '@pnpm/installing.context';
+import { mutateModulesInSingleProject } from '@pnpm/installing.deps-installer';
+import { getAllDependenciesFromManifest } from '@pnpm/pkg-manifest.utils';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { findWorkspaceProjects } from '@pnpm/workspace.projects-reader';
+import { updateWorkspaceManifest } from '@pnpm/workspace.workspace-manifest-writer';
+import { pick, without } from 'ramda';
+import { renderHelp } from 'render-help';
+import { getSaveType } from './getSaveType.js';
+import { recursive } from './recursive.js';
+class RemoveMissingDepsError extends PnpmError {
+    constructor(opts) {
+        let message = 'Cannot remove ';
+        message += `${opts.nonMatchedDependencies.map(dep => `'${dep}'`).join(', ')}: `;
+        if (opts.availableDependencies.length > 0) {
+            message += `no such ${opts.nonMatchedDependencies.length > 1 ? 'dependencies' : 'dependency'} `;
+            message += `found${opts.targetDependenciesField ? ` in '${opts.targetDependenciesField}'` : ''}`;
+            const hint = `Available dependencies: ${opts.availableDependencies.join(', ')}`;
+            super('CANNOT_REMOVE_MISSING_DEPS', message, { hint });
+            return;
+        }
+        message += opts.targetDependenciesField
+            ? `project has no '${opts.targetDependenciesField}'`
+            : 'project has no dependencies of any kind';
+        super('CANNOT_REMOVE_MISSING_DEPS', message);
+    }
+}
+export function rcOptionsTypes() {
+    return pick([
+        'cache-dir',
+        'global-dir',
+        'global-pnpmfile',
+        'global',
+        'lockfile-dir',
+        'lockfile-directory',
+        'lockfile-only',
+        'lockfile',
+        'node-linker',
+        'package-import-method',
+        'pnpmfile',
+        'reporter',
+        'save-dev',
+        'save-optional',
+        'save-prod',
+        'shared-workspace-lockfile',
+        'store-dir',
+        'strict-peer-dependencies',
+        'virtual-store-dir',
+    ], allTypes);
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    ...pick(['force'], allTypes),
+    recursive: Boolean,
+});
+export function help() {
+    return renderHelp({
+        aliases: ['rm', 'uninstall', 'un'],
+        description: 'Removes packages from `node_modules` and from the project\'s `package.json`.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Remove from every package found in subdirectories \
+or from every workspace package, when executed inside a workspace. \
+For options that may be used with `-r`, see "pnpm help recursive"',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    {
+                        description: 'Remove the dependency only from "devDependencies"',
+                        name: '--save-dev',
+                        shortAlias: '-D',
+                    },
+                    {
+                        description: 'Remove the dependency only from "optionalDependencies"',
+                        name: '--save-optional',
+                        shortAlias: '-O',
+                    },
+                    {
+                        description: 'Remove the dependency only from "dependencies"',
+                        name: '--save-prod',
+                        shortAlias: '-P',
+                    },
+                    OPTIONS.globalDir,
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('remove'),
+        usages: ['pnpm remove <pkg>[@<version>]...'],
+    });
+}
+// Unlike npm, pnpm does not treat "r" as an alias of "remove".
+// This way we avoid the confusion about whether "pnpm r" means remove, run, or recursive.
+export const commandNames = ['remove', 'uninstall', 'rm', 'un', 'uni'];
+export const completion = async (cliOpts) => {
+    return readDepNameCompletions(cliOpts.dir);
+};
+export async function handler(opts, params) {
+    if (params.length === 0)
+        throw new PnpmError('MUST_REMOVE_SOMETHING', 'At least one dependency name should be specified for removal');
+    if (opts.global) {
+        if (!opts.bin) {
+            throw new PnpmError('NO_GLOBAL_BIN_DIR', 'Unable to find the global bin directory', {
+                hint: 'Run "pnpm setup" to create it automatically, or set the global-bin-dir setting, or the PNPM_HOME env variable. The global bin directory should be in the PATH.',
+            });
+        }
+        return handleGlobalRemove(opts, params);
+    }
+    const include = {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        optionalDependencies: opts.optional !== false,
+    };
+    const store = await createStoreController(opts);
+    if (opts.recursive && (opts.allProjects != null) && (opts.selectedProjectsGraph != null) && opts.workspaceDir) {
+        await recursive(opts.allProjects, params, {
+            ...opts,
+            allProjectsGraph: opts.allProjectsGraph,
+            include,
+            selectedProjectsGraph: opts.selectedProjectsGraph,
+            storeControllerAndDir: store,
+            workspaceDir: opts.workspaceDir,
+        }, 'remove');
+        return;
+    }
+    const removeOpts = Object.assign(opts, {
+        linkWorkspacePackagesDepth: opts.linkWorkspacePackages === 'deep' ? Infinity : opts.linkWorkspacePackages ? 0 : -1,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+        include,
+    });
+    const allProjects = opts.allProjects ?? (opts.workspaceDir
+        ? await findWorkspaceProjects(opts.workspaceDir, { ...opts, patterns: opts.workspacePackagePatterns })
+        : undefined);
+    // @ts-expect-error
+    removeOpts['workspacePackages'] = allProjects
+        ? arrayOfWorkspacePackagesToMap(allProjects)
+        : undefined;
+    const targetDependenciesField = getSaveType(opts);
+    const { manifest: currentManifest, writeProjectManifest, } = await readProjectManifest(opts.dir, opts);
+    const availableDependencies = Object.keys(targetDependenciesField === undefined
+        ? getAllDependenciesFromManifest(currentManifest)
+        : currentManifest[targetDependenciesField] ?? {});
+    const nonMatchedDependencies = without(availableDependencies, params);
+    if (nonMatchedDependencies.length !== 0) {
+        throw new RemoveMissingDepsError({
+            availableDependencies,
+            nonMatchedDependencies,
+            targetDependenciesField,
+        });
+    }
+    const mutationResult = await mutateModulesInSingleProject({
+        binsDir: opts.bin,
+        dependencyNames: params,
+        manifest: currentManifest,
+        mutation: 'uninstallSome',
+        rootDir: opts.dir,
+        targetDependenciesField,
+    }, removeOpts);
+    await writeProjectManifest(mutationResult.updatedProject.manifest);
+    const updatedProjects = [];
+    if (allProjects != null) {
+        for (const project of allProjects) {
+            if (project.rootDir === mutationResult.updatedProject.rootDir) {
+                updatedProjects.push({
+                    ...project,
+                    manifest: mutationResult.updatedProject.manifest,
+                });
+            }
+            else {
+                updatedProjects.push(project);
+            }
+        }
+    }
+    await updateWorkspaceManifest(opts.workspaceDir ?? opts.dir, {
+        cleanupUnusedCatalogs: opts.cleanupUnusedCatalogs,
+        allProjects: updatedProjects,
+    });
+}
+//# sourceMappingURL=remove.js.map

package/lib/unlink.d.ts

@@ -0,0 +1,6 @@
+import * as install from './install.js';
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare const rcOptionsTypes: typeof install.rcOptionsTypes;
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: install.InstallCommandOptions, params: string[]): Promise<undefined | string>;

package/lib/unlink.js

@@ -0,0 +1,62 @@
+import { UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { writeSettings } from '@pnpm/config.writer';
+import { renderHelp } from 'render-help';
+import * as install from './install.js';
+export const cliOptionsTypes = install.cliOptionsTypes;
+export const rcOptionsTypes = install.rcOptionsTypes;
+export const commandNames = ['unlink', 'dislink'];
+export function help() {
+    return renderHelp({
+        aliases: ['dislink'],
+        description: 'Removes the link created by `pnpm link` and reinstalls package if it is saved in `package.json`',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Unlink in every package found in subdirectories \
+or in every workspace package, when executed inside a workspace. \
+For options that may be used with `-r`, see "pnpm help recursive"',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+        ],
+        url: docsUrl('unlink'),
+        usages: [
+            'pnpm unlink (in package dir)',
+            'pnpm unlink <pkg>...',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (!opts.overrides)
+        return 'Nothing to unlink';
+    if (!params || (params.length === 0)) {
+        for (const selector in opts.overrides) {
+            if (opts.overrides[selector].startsWith('link:')) {
+                delete opts.overrides[selector];
+            }
+        }
+    }
+    else {
+        for (const selector in opts.overrides) {
+            if (opts.overrides[selector].startsWith('link:') && params.includes(selector)) {
+                delete opts.overrides[selector];
+            }
+        }
+    }
+    await writeSettings({
+        workspaceDir: opts.workspaceDir ?? opts.rootProjectManifestDir,
+        rootProjectManifestDir: opts.rootProjectManifestDir,
+        updatedSettings: {
+            overrides: opts.overrides,
+        },
+    });
+    await install.handler(opts);
+    return undefined;
+}
+//# sourceMappingURL=unlink.js.map