@pnpm/deps.inspection.commands 1000.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { list, ll, why } from './listing/index.js';
+export { outdated } from './outdated/index.js';

package/lib/index.js

@@ -0,0 +1,3 @@
+export { list, ll, why } from './listing/index.js';
+export { outdated } from './outdated/index.js';
+//# sourceMappingURL=index.js.map

package/lib/listing/common.d.ts

@@ -0,0 +1,26 @@
+import type { Finder, IncludedDependencies } from '@pnpm/types';
+export type ReportAs = 'parseable' | 'json' | 'tree';
+export declare function computeInclude(opts: {
+    production?: boolean;
+    dev?: boolean;
+    optional?: boolean;
+}): IncludedDependencies;
+export declare function resolveFinders(opts: {
+    findBy?: string[];
+    finders?: Record<string, Finder>;
+}): Finder[];
+export declare function determineReportAs(opts: {
+    parseable?: boolean;
+    json?: boolean;
+}): ReportAs;
+export declare const shorthands: Record<string, string>;
+export declare const BASE_RC_OPTION_KEYS: readonly ["dev", "global-dir", "global", "json", "long", "only", "optional", "parseable", "production"];
+export declare const SHARED_CLI_HELP_OPTIONS: ({
+    description: string;
+    name: string;
+    shortAlias: string;
+} | {
+    shortAlias?: undefined;
+    description: string;
+    name: string;
+})[];

package/lib/listing/common.js

@@ -0,0 +1,79 @@
+import { PnpmError } from '@pnpm/error';
+export function computeInclude(opts) {
+    return {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        optionalDependencies: opts.optional !== false,
+    };
+}
+export function resolveFinders(opts) {
+    const finders = [];
+    if (opts.findBy) {
+        for (const finderName of opts.findBy) {
+            if (opts.finders?.[finderName] == null) {
+                throw new PnpmError('FINDER_NOT_FOUND', `No finder with name ${finderName} is found`);
+            }
+            finders.push(opts.finders[finderName]);
+        }
+    }
+    return finders;
+}
+export function determineReportAs(opts) {
+    return opts.parseable ? 'parseable' : (opts.json ? 'json' : 'tree');
+}
+export const shorthands = {
+    D: '--dev',
+    P: '--production',
+};
+export const BASE_RC_OPTION_KEYS = [
+    'dev',
+    'global-dir',
+    'global',
+    'json',
+    'long',
+    'only',
+    'optional',
+    'parseable',
+    'production',
+];
+export const SHARED_CLI_HELP_OPTIONS = [
+    {
+        description: 'Perform command on every package in subdirectories \
+or on 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: 'Show extended information',
+        name: '--long',
+    },
+    {
+        description: 'Show parseable output instead of tree view',
+        name: '--parseable',
+    },
+    {
+        description: 'Show information in JSON format',
+        name: '--json',
+    },
+    {
+        description: 'List packages in the global install prefix instead of in the current project',
+        name: '--global',
+        shortAlias: '-g',
+    },
+    {
+        description: 'Display only the dependency graph for packages in `dependencies` and `optionalDependencies`',
+        name: '--prod',
+        shortAlias: '-P',
+    },
+    {
+        description: 'Display only the dependency graph for packages in `devDependencies`',
+        name: '--dev',
+        shortAlias: '-D',
+    },
+    {
+        description: "Don't display packages from `optionalDependencies`",
+        name: '--no-optional',
+    },
+];
+//# sourceMappingURL=common.js.map

package/lib/listing/index.d.ts

@@ -0,0 +1,4 @@
+import * as list from './list.js';
+import * as ll from './ll.js';
+import * as why from './why.js';
+export { list, ll, why };

package/lib/listing/index.js

@@ -0,0 +1,5 @@
+import * as list from './list.js';
+import * as ll from './ll.js';
+import * as why from './why.js';
+export { list, ll, why };
+//# sourceMappingURL=index.js.map

package/lib/listing/list.d.ts

@@ -0,0 +1,41 @@
+import { type Config } from '@pnpm/config.reader';
+import type { Finder, IncludedDependencies } from '@pnpm/types';
+export declare const EXCLUDE_PEERS_HELP: {
+    description: string;
+    name: string;
+};
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export { shorthands } from './common.js';
+export declare const commandNames: string[];
+export declare function help(): string;
+export type ListCommandOptions = Pick<Config, 'allProjects' | 'dev' | 'dir' | 'finders' | 'optional' | 'production' | 'selectedProjectsGraph' | 'modulesDir' | 'virtualStoreDirMaxLength'> & Partial<Pick<Config, 'cliOptions'>> & {
+    alwaysPrintRootPackage?: boolean;
+    depth?: number;
+    excludePeers?: boolean;
+    json?: boolean;
+    lockfileDir?: string;
+    lockfileOnly?: boolean;
+    long?: boolean;
+    parseable?: boolean;
+    onlyProjects?: boolean;
+    recursive?: boolean;
+    findBy?: string[];
+} & Partial<Pick<Config, 'global' | 'globalPkgDir'>>;
+export declare function handler(opts: ListCommandOptions, params: string[]): Promise<string>;
+export declare function render(prefixes: string[], params: string[], opts: {
+    alwaysPrintRootPackage?: boolean;
+    depth?: number;
+    excludePeers?: boolean;
+    include: IncludedDependencies;
+    lockfileDir: string;
+    checkWantedLockfileOnly?: boolean;
+    long?: boolean;
+    json?: boolean;
+    onlyProjects?: boolean;
+    parseable?: boolean;
+    modulesDir?: string;
+    virtualStoreDirMaxLength: number;
+    finders?: Record<string, Finder>;
+    findBy?: string[];
+}): Promise<string>;

package/lib/listing/list.js

@@ -0,0 +1,115 @@
+import { FILTERING, OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { list, listForPackages } from '@pnpm/deps.inspection.list';
+import { listGlobalPackages } from '@pnpm/global.commands';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { BASE_RC_OPTION_KEYS, computeInclude, determineReportAs, resolveFinders, SHARED_CLI_HELP_OPTIONS } from './common.js';
+import { listRecursive } from './recursive.js';
+export const EXCLUDE_PEERS_HELP = {
+    description: 'Exclude peer dependencies',
+    name: '--exclude-peers',
+};
+export function rcOptionsTypes() {
+    return pick([
+        ...BASE_RC_OPTION_KEYS,
+        'depth',
+        'lockfile-only',
+    ], allTypes);
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    'exclude-peers': Boolean,
+    'only-projects': Boolean,
+    recursive: Boolean,
+    'find-by': [String, Array],
+});
+export { shorthands } from './common.js';
+export const commandNames = ['list', 'ls'];
+export function help() {
+    return renderHelp({
+        aliases: ['list', 'ls', 'la', 'll'],
+        description: 'When run as ll or la, it shows extended information by default. \
+All dependencies are printed by default. Search by patterns is supported. \
+For example: pnpm ls babel-* eslint-*',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    ...SHARED_CLI_HELP_OPTIONS,
+                    {
+                        description: 'Max display depth of the dependency tree',
+                        name: '--depth <number>',
+                    },
+                    {
+                        description: 'Display only direct dependencies',
+                        name: '--depth 0',
+                    },
+                    {
+                        description: 'Display only projects. Useful in a monorepo. `pnpm ls -r --depth -1` lists all projects in a monorepo',
+                        name: '--depth -1',
+                    },
+                    {
+                        description: 'Display only dependencies that are also projects within the workspace',
+                        name: '--only-projects',
+                    },
+                    {
+                        description: 'List packages from the lockfile only, without checking node_modules.',
+                        name: '--lockfile-only',
+                    },
+                    EXCLUDE_PEERS_HELP,
+                    OPTIONS.globalDir,
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('list'),
+        usages: [
+            'pnpm ls [<pkg> ...]',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (opts.global && opts.globalPkgDir) {
+        return listGlobalPackages(opts.globalPkgDir, params);
+    }
+    const include = computeInclude(opts);
+    const depth = opts.cliOptions?.['depth'] ?? 0;
+    if (opts.recursive && (opts.selectedProjectsGraph != null)) {
+        const pkgs = Object.values(opts.selectedProjectsGraph).map((wsPkg) => wsPkg.package);
+        return listRecursive(pkgs, params, { ...opts, depth, include, checkWantedLockfileOnly: opts.lockfileOnly, onlyProjects: opts.cliOptions?.['only-projects'] ?? opts.onlyProjects });
+    }
+    return render([opts.dir], params, {
+        ...opts,
+        depth,
+        include,
+        lockfileDir: opts.lockfileDir ?? opts.dir,
+        checkWantedLockfileOnly: opts.lockfileOnly,
+        onlyProjects: opts.cliOptions?.['only-projects'] ?? opts.onlyProjects,
+    });
+}
+export async function render(prefixes, params, opts) {
+    const finders = resolveFinders(opts);
+    const listOpts = {
+        alwaysPrintRootPackage: opts.alwaysPrintRootPackage,
+        depth: opts.depth ?? 0,
+        excludePeerDependencies: opts.excludePeers,
+        include: opts.include,
+        lockfileDir: opts.lockfileDir,
+        checkWantedLockfileOnly: opts.checkWantedLockfileOnly,
+        long: opts.long,
+        onlyProjects: opts.onlyProjects,
+        reportAs: determineReportAs(opts),
+        showExtraneous: false,
+        showSummary: true,
+        modulesDir: opts.modulesDir,
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        finders,
+    };
+    return (params.length > 0) || listOpts.finders.length > 0
+        ? listForPackages(params, prefixes, listOpts)
+        : list(prefixes, listOpts);
+}
+//# sourceMappingURL=list.js.map

package/lib/listing/ll.d.ts

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

package/lib/listing/ll.js

@@ -0,0 +1,12 @@
+import { omit } from 'ramda';
+import * as list from './list.js';
+export const commandNames = ['ll', 'la'];
+export const rcOptionsTypes = list.rcOptionsTypes;
+export function cliOptionsTypes() {
+    return omit(['long'], list.cliOptionsTypes());
+}
+export const help = list.help;
+export async function handler(opts, params) {
+    return list.handler({ ...opts, long: true }, params);
+}
+//# sourceMappingURL=ll.js.map

package/lib/listing/recursive.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from '@pnpm/config.reader';
+import type { IncludedDependencies, Project } from '@pnpm/types';
+export declare function listRecursive(pkgs: Project[], params: string[], opts: Pick<Config, 'lockfileDir' | 'virtualStoreDirMaxLength'> & {
+    depth?: number;
+    include: IncludedDependencies;
+    long?: boolean;
+    parseable?: boolean;
+    lockfileDir?: string;
+    checkWantedLockfileOnly?: boolean;
+    onlyProjects?: boolean;
+}): Promise<string>;

package/lib/listing/recursive.js

@@ -0,0 +1,36 @@
+import assert from 'node:assert';
+import util from 'node:util';
+import { logger } from '@pnpm/logger';
+import { render } from './list.js';
+export async function listRecursive(pkgs, params, opts) {
+    const depth = opts.depth ?? 0;
+    if (opts.lockfileDir) {
+        return render(pkgs.map((pkg) => pkg.rootDir), params, {
+            ...opts,
+            alwaysPrintRootPackage: depth === -1,
+            lockfileDir: opts.lockfileDir,
+        });
+    }
+    const outputs = (await Promise.all(pkgs.map(async ({ rootDir }) => {
+        try {
+            return await render([rootDir], params, {
+                ...opts,
+                alwaysPrintRootPackage: depth === -1,
+                lockfileDir: opts.lockfileDir ?? rootDir,
+            });
+        }
+        catch (err) {
+            assert(util.types.isNativeError(err));
+            const errWithPrefix = Object.assign(err, {
+                prefix: rootDir,
+            });
+            logger.info(errWithPrefix);
+            throw errWithPrefix;
+        }
+    }))).filter(Boolean);
+    if (outputs.length === 0)
+        return '';
+    const joiner = typeof depth === 'number' && depth > -1 ? '\n\n' : '\n';
+    return outputs.join(joiner);
+}
+//# sourceMappingURL=recursive.js.map

package/lib/listing/why.d.ts

@@ -0,0 +1,7 @@
+import { type ListCommandOptions } from './list.js';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export { shorthands } from './common.js';
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function handler(opts: ListCommandOptions, params: string[]): Promise<string>;

package/lib/listing/why.js

@@ -0,0 +1,70 @@
+import { FILTERING, OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { whyForPackages } from '@pnpm/deps.inspection.list';
+import { PnpmError } from '@pnpm/error';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { BASE_RC_OPTION_KEYS, computeInclude, determineReportAs, resolveFinders, SHARED_CLI_HELP_OPTIONS } from './common.js';
+import { EXCLUDE_PEERS_HELP } from './list.js';
+export function rcOptionsTypes() {
+    return pick([...BASE_RC_OPTION_KEYS, 'depth'], allTypes);
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    'exclude-peers': Boolean,
+    recursive: Boolean,
+    'find-by': [String, Array],
+});
+export { shorthands } from './common.js';
+export const commandNames = ['why'];
+export function help() {
+    return renderHelp({
+        description: `Shows the packages that depend on <pkg>
+For example: pnpm why babel-* eslint-*`,
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    ...SHARED_CLI_HELP_OPTIONS,
+                    {
+                        description: 'Max display depth of the reverse dependency tree',
+                        name: '--depth <number>',
+                    },
+                    EXCLUDE_PEERS_HELP,
+                    OPTIONS.globalDir,
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('why'),
+        usages: [
+            'pnpm why <pkg> ...',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (params.length === 0 && opts.findBy == null) {
+        throw new PnpmError('MISSING_PACKAGE_NAME', '`pnpm why` requires the package name or --find-by=<finder-name>');
+    }
+    const include = computeInclude(opts);
+    const finders = resolveFinders(opts);
+    const lockfileDir = opts.lockfileDir ?? opts.dir;
+    const reportAs = determineReportAs(opts);
+    const depth = opts.cliOptions?.['depth'];
+    const projectPaths = opts.recursive && opts.selectedProjectsGraph
+        ? Object.keys(opts.selectedProjectsGraph)
+        : [opts.dir];
+    return whyForPackages(params, projectPaths, {
+        depth,
+        include,
+        long: opts.long,
+        lockfileDir,
+        reportAs,
+        modulesDir: opts.modulesDir,
+        checkWantedLockfileOnly: opts.lockfileOnly,
+        finders,
+    });
+}
+//# sourceMappingURL=why.js.map

package/lib/outdated/index.d.ts

@@ -0,0 +1,2 @@
+import * as outdated from './outdated.js';
+export { outdated };

package/lib/outdated/index.js

@@ -0,0 +1,3 @@
+import * as outdated from './outdated.js';
+export { outdated };
+//# sourceMappingURL=index.js.map

package/lib/outdated/outdated.d.ts

@@ -0,0 +1,36 @@
+import type { CompletionFunc } from '@pnpm/cli.command';
+import { type Config } from '@pnpm/config.reader';
+import { type OutdatedPackage } from '@pnpm/deps.inspection.outdated';
+import type { DependenciesField, PackageManifest } from '@pnpm/types';
+import { type OutdatedWithVersionDiff } from './utils.js';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare const shorthands: Record<string, string>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare const completion: CompletionFunc;
+export type OutdatedCommandOptions = {
+    compatible?: boolean;
+    long?: boolean;
+    recursive?: boolean;
+    format?: 'table' | 'list' | 'json';
+    sortBy?: 'name';
+} & Pick<Config, 'allProjects' | 'ca' | 'cacheDir' | 'catalogs' | 'cert' | 'dev' | 'dir' | 'engineStrict' | 'fetchRetries' | 'fetchRetryFactor' | 'fetchRetryMaxtimeout' | 'fetchRetryMintimeout' | 'fetchTimeout' | 'global' | 'httpProxy' | 'httpsProxy' | 'key' | 'localAddress' | 'lockfileDir' | 'minimumReleaseAge' | 'minimumReleaseAgeExclude' | 'networkConcurrency' | 'noProxy' | 'offline' | 'optional' | 'production' | 'rawConfig' | 'registries' | 'selectedProjectsGraph' | 'strictSsl' | 'tag' | 'userAgent' | 'updateConfig'> & Partial<Pick<Config, 'globalPkgDir' | 'userConfig'>>;
+export declare function handler(opts: OutdatedCommandOptions, params?: string[]): Promise<{
+    output: string;
+    exitCode: number;
+}>;
+export interface OutdatedPackageJSONOutput {
+    current?: string;
+    latest?: string;
+    wanted: string;
+    isDeprecated: boolean;
+    dependencyType: DependenciesField;
+    latestManifest?: PackageManifest;
+}
+export declare function getCellWidth(data: string[][], columnNumber: number, maxWidth: number): number;
+export declare function toOutdatedWithVersionDiff<Pkg extends OutdatedPackage>(outdated: Pkg): Pkg & OutdatedWithVersionDiff;
+export declare function renderPackageName({ belongsTo, packageName }: OutdatedPackage): string;
+export declare function renderCurrent({ current, wanted }: OutdatedPackage): string;
+export declare function renderLatest(outdatedPkg: OutdatedWithVersionDiff): string;
+export declare function renderDetails({ latestManifest }: OutdatedPackage): string;

package/lib/outdated/outdated.js

@@ -0,0 +1,321 @@
+import { stripVTControlCharacters as stripAnsi } from 'node:util';
+import { FILTERING, OPTIONS, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl, readDepNameCompletions, readProjectManifestOnly, TABLE_OPTIONS, } from '@pnpm/cli.utils';
+import colorizeSemverDiff from '@pnpm/colorize-semver-diff';
+import { types as allTypes } from '@pnpm/config.reader';
+import { outdatedDepsOfProjects, } from '@pnpm/deps.inspection.outdated';
+import { PnpmError } from '@pnpm/error';
+import { scanGlobalPackages } from '@pnpm/global.packages';
+import semverDiff from '@pnpm/semver-diff';
+import { table } from '@zkochan/table';
+import chalk from 'chalk';
+import { pick, sortWith } from 'ramda';
+import { renderHelp } from 'render-help';
+import { outdatedRecursive } from './recursive.js';
+import { DEFAULT_COMPARATORS, NAME_COMPARATOR, } from './utils.js';
+export function rcOptionsTypes() {
+    return {
+        ...pick([
+            'depth',
+            'dev',
+            'global-dir',
+            'global',
+            'long',
+            'optional',
+            'production',
+        ], allTypes),
+        compatible: Boolean,
+        format: ['table', 'list', 'json'],
+        'sort-by': 'name',
+    };
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    recursive: Boolean,
+});
+export const shorthands = {
+    D: '--dev',
+    P: '--production',
+    table: '--format=table',
+    'no-table': '--format=list',
+    json: '--format=json',
+};
+export const commandNames = ['outdated'];
+export function help() {
+    return renderHelp({
+        description: `Check for outdated packages. The check can be limited to a subset of the installed packages by providing arguments (patterns are supported).
+
+Examples:
+pnpm outdated
+pnpm outdated --long
+pnpm outdated gulp-* @babel/core`,
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Print only versions that satisfy specs in package.json',
+                        name: '--compatible',
+                    },
+                    {
+                        description: 'By default, details about the outdated packages (such as a link to the repo) are not displayed. \
+To display the details, pass this option.',
+                        name: '--long',
+                    },
+                    {
+                        description: 'Check for outdated dependencies 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',
+                    },
+                    {
+                        description: 'Prints the outdated packages in a list. Good for small consoles',
+                        name: '--no-table',
+                    },
+                    {
+                        description: 'Check only "dependencies" and "optionalDependencies"',
+                        name: '--prod',
+                        shortAlias: '-P',
+                    },
+                    {
+                        description: 'Check only "devDependencies"',
+                        name: '--dev',
+                        shortAlias: '-D',
+                    },
+                    {
+                        description: 'Don\'t check "optionalDependencies"',
+                        name: '--no-optional',
+                    },
+                    {
+                        description: 'Prints the outdated dependencies in the given format. Default is "table". Supported options: "table, list, json"',
+                        name: '--format <format>',
+                    },
+                    {
+                        description: 'Specify the sorting method. Currently only `name` is supported.',
+                        name: '--sort-by',
+                    },
+                    OPTIONS.globalDir,
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('outdated'),
+        usages: ['pnpm outdated [<pkg> ...]'],
+    });
+}
+export const completion = async (cliOpts) => {
+    return readDepNameCompletions(cliOpts.dir);
+};
+export async function handler(opts, params = []) {
+    const include = {
+        dependencies: opts.production !== false,
+        devDependencies: opts.dev !== false,
+        optionalDependencies: opts.optional !== false,
+    };
+    if (opts.recursive && (opts.selectedProjectsGraph != null)) {
+        const pkgs = Object.values(opts.selectedProjectsGraph).map((wsPkg) => wsPkg.package);
+        return outdatedRecursive(pkgs, params, { ...opts, include });
+    }
+    let packages;
+    if (opts.global && opts.globalPkgDir) {
+        const globalPackages = scanGlobalPackages(opts.globalPkgDir);
+        packages = await Promise.all(globalPackages.map(async (pkg) => ({
+            rootDir: pkg.installDir,
+            manifest: await readProjectManifestOnly(pkg.installDir, opts),
+        })));
+    }
+    else {
+        const manifest = await readProjectManifestOnly(opts.dir, opts);
+        packages = [
+            {
+                rootDir: opts.dir,
+                manifest,
+            },
+        ];
+    }
+    const outdatedPerProject = await outdatedDepsOfProjects(packages, params, {
+        ...opts,
+        fullMetadata: opts.long,
+        ignoreDependencies: opts.updateConfig?.ignoreDependencies,
+        include,
+        minimumReleaseAge: opts.minimumReleaseAge,
+        minimumReleaseAgeExclude: opts.minimumReleaseAgeExclude,
+        retry: {
+            factor: opts.fetchRetryFactor,
+            maxTimeout: opts.fetchRetryMaxtimeout,
+            minTimeout: opts.fetchRetryMintimeout,
+            retries: opts.fetchRetries,
+        },
+        timeout: opts.fetchTimeout,
+    });
+    const outdatedPackages = outdatedPerProject.flat();
+    let output;
+    switch (opts.format ?? 'table') {
+        case 'table': {
+            output = renderOutdatedTable(outdatedPackages, opts);
+            break;
+        }
+        case 'list': {
+            output = renderOutdatedList(outdatedPackages, opts);
+            break;
+        }
+        case 'json': {
+            output = renderOutdatedJSON(outdatedPackages, opts);
+            break;
+        }
+        default: {
+            throw new PnpmError('BAD_OUTDATED_FORMAT', `Unsupported format: ${opts.format?.toString() ?? 'undefined'}`);
+        }
+    }
+    return {
+        output,
+        exitCode: outdatedPackages.length === 0 ? 0 : 1,
+    };
+}
+function renderOutdatedTable(outdatedPackages, opts) {
+    if (outdatedPackages.length === 0)
+        return '';
+    const columnNames = [
+        'Package',
+        'Current',
+        'Latest',
+    ];
+    const columnFns = [
+        renderPackageName,
+        renderCurrent,
+        renderLatest,
+    ];
+    if (opts.long) {
+        columnNames.push('Details');
+        columnFns.push(renderDetails);
+    }
+    // Avoid the overhead of allocating a new array caused by calling `array.map()`
+    for (let i = 0; i < columnNames.length; i++)
+        columnNames[i] = chalk.blueBright(columnNames[i]);
+    const data = [
+        columnNames,
+        ...sortOutdatedPackages(outdatedPackages, { sortBy: opts.sortBy })
+            .map((outdatedPkg) => columnFns.map((fn) => fn(outdatedPkg))),
+    ];
+    const tableOptions = {
+        ...TABLE_OPTIONS,
+    };
+    if (opts.long) {
+        const detailsColumnMaxWidth = outdatedPackages.filter(pkg => pkg.latestManifest && !pkg.latestManifest.deprecated).reduce((maxWidth, pkg) => {
+            const cellWidth = pkg.latestManifest?.homepage?.length ?? 0;
+            return Math.max(maxWidth, cellWidth);
+        }, 40);
+        tableOptions.columns = {
+            // Detail column:
+            3: {
+                width: detailsColumnMaxWidth,
+                wrapWord: true,
+            },
+        };
+    }
+    return table(data, tableOptions);
+}
+function renderOutdatedList(outdatedPackages, opts) {
+    if (outdatedPackages.length === 0)
+        return '';
+    return sortOutdatedPackages(outdatedPackages, { sortBy: opts.sortBy })
+        .map((outdatedPkg) => {
+        let info = `${chalk.bold(renderPackageName(outdatedPkg))}
+${renderCurrent(outdatedPkg)} ${chalk.grey('=>')} ${renderLatest(outdatedPkg)}`;
+        if (opts.long) {
+            const details = renderDetails(outdatedPkg);
+            if (details) {
+                info += `\n${details}`;
+            }
+        }
+        return info;
+    })
+        .join('\n\n') + '\n';
+}
+function renderOutdatedJSON(outdatedPackages, opts) {
+    const outdatedPackagesJSON = sortOutdatedPackages(outdatedPackages, { sortBy: opts.sortBy })
+        .reduce((acc, outdatedPkg) => {
+        acc[outdatedPkg.packageName] = {
+            current: outdatedPkg.current,
+            latest: outdatedPkg.latestManifest?.version,
+            wanted: outdatedPkg.wanted,
+            isDeprecated: Boolean(outdatedPkg.latestManifest?.deprecated),
+            dependencyType: outdatedPkg.belongsTo,
+        };
+        if (opts.long) {
+            acc[outdatedPkg.packageName].latestManifest = outdatedPkg.latestManifest;
+        }
+        return acc;
+    }, {});
+    return JSON.stringify(outdatedPackagesJSON, null, 2);
+}
+function sortOutdatedPackages(outdatedPackages, opts) {
+    const sortBy = opts?.sortBy;
+    const comparators = (sortBy === 'name') ? [NAME_COMPARATOR] : DEFAULT_COMPARATORS;
+    return sortWith(comparators, outdatedPackages.map(toOutdatedWithVersionDiff));
+}
+export function getCellWidth(data, columnNumber, maxWidth) {
+    const maxCellWidth = data.reduce((cellWidth, row) => {
+        const cellLines = stripAnsi(row[columnNumber]).split('\n');
+        const currentCellWidth = cellLines.reduce((lineWidth, line) => {
+            return Math.max(lineWidth, line.length);
+        }, 0);
+        return Math.max(cellWidth, currentCellWidth);
+    }, 0);
+    return Math.min(maxWidth, maxCellWidth);
+}
+export function toOutdatedWithVersionDiff(outdated) {
+    if (outdated.latestManifest != null) {
+        return {
+            ...outdated,
+            ...semverDiff.default(outdated.wanted, outdated.latestManifest.version),
+        };
+    }
+    return {
+        ...outdated,
+        change: 'unknown',
+    };
+}
+export function renderPackageName({ belongsTo, packageName }) {
+    switch (belongsTo) {
+        case 'devDependencies': return `${packageName} ${chalk.dim('(dev)')}`;
+        case 'optionalDependencies': return `${packageName} ${chalk.dim('(optional)')}`;
+        default: return packageName;
+    }
+}
+export function renderCurrent({ current, wanted }) {
+    const output = current ?? 'missing';
+    if (current === wanted)
+        return output;
+    return `${output} (wanted ${wanted})`;
+}
+export function renderLatest(outdatedPkg) {
+    const { latestManifest, change, diff } = outdatedPkg;
+    if (latestManifest == null)
+        return '';
+    if (change === null || (diff == null)) {
+        return latestManifest.deprecated
+            ? chalk.redBright.bold('Deprecated')
+            : latestManifest.version;
+    }
+    const versionText = colorizeSemverDiff.default({ change, diff });
+    if (latestManifest.deprecated) {
+        return `${versionText} ${chalk.redBright('(deprecated)')}`;
+    }
+    return versionText;
+}
+export function renderDetails({ latestManifest }) {
+    if (latestManifest == null)
+        return '';
+    const outputs = [];
+    if (latestManifest.deprecated) {
+        outputs.push(chalk.redBright(latestManifest.deprecated));
+    }
+    if (latestManifest.homepage) {
+        outputs.push(chalk.underline(latestManifest.homepage));
+    }
+    return outputs.join('\n');
+}
+//# sourceMappingURL=outdated.js.map

package/lib/outdated/recursive.d.ts

@@ -0,0 +1,17 @@
+import type { IncludedDependencies, ProjectManifest, ProjectRootDir } from '@pnpm/types';
+import { type OutdatedCommandOptions, type OutdatedPackageJSONOutput } from './outdated.js';
+export declare function outdatedRecursive(pkgs: Array<{
+    rootDir: ProjectRootDir;
+    manifest: ProjectManifest;
+}>, params: string[], opts: OutdatedCommandOptions & {
+    include: IncludedDependencies;
+}): Promise<{
+    output: string;
+    exitCode: number;
+}>;
+export interface OutdatedPackageInWorkspaceJSONOutput extends OutdatedPackageJSONOutput {
+    dependentPackages: Array<{
+        name: string;
+        location: string;
+    }>;
+}

package/lib/outdated/recursive.js

@@ -0,0 +1,156 @@
+import { TABLE_OPTIONS } from '@pnpm/cli.utils';
+import { outdatedDepsOfProjects, } from '@pnpm/deps.inspection.outdated';
+import { PnpmError } from '@pnpm/error';
+import { table } from '@zkochan/table';
+import chalk from 'chalk';
+import { isEmpty, sortWith } from 'ramda';
+import { getCellWidth, renderCurrent, renderDetails, renderLatest, renderPackageName, toOutdatedWithVersionDiff, } from './outdated.js';
+import { DEFAULT_COMPARATORS } from './utils.js';
+const DEP_PRIORITY = {
+    dependencies: 1,
+    devDependencies: 2,
+    optionalDependencies: 0,
+};
+const COMPARATORS = [
+    ...DEFAULT_COMPARATORS,
+    (o1, o2) => DEP_PRIORITY[o1.belongsTo] - DEP_PRIORITY[o2.belongsTo],
+];
+export async function outdatedRecursive(pkgs, params, opts) {
+    const outdatedMap = {};
+    const outdatedPackagesByProject = await outdatedDepsOfProjects(pkgs, params, {
+        ...opts,
+        fullMetadata: opts.long,
+        ignoreDependencies: opts.updateConfig?.ignoreDependencies,
+        minimumReleaseAge: opts.minimumReleaseAge,
+        minimumReleaseAgeExclude: opts.minimumReleaseAgeExclude,
+        retry: {
+            factor: opts.fetchRetryFactor,
+            maxTimeout: opts.fetchRetryMaxtimeout,
+            minTimeout: opts.fetchRetryMintimeout,
+            retries: opts.fetchRetries,
+        },
+        timeout: opts.fetchTimeout,
+    });
+    for (let i = 0; i < outdatedPackagesByProject.length; i++) {
+        const { rootDir, manifest } = pkgs[i];
+        for (const outdatedPkg of outdatedPackagesByProject[i]) {
+            const key = JSON.stringify([outdatedPkg.packageName, outdatedPkg.current, outdatedPkg.belongsTo]);
+            if (!outdatedMap[key]) {
+                outdatedMap[key] = { ...outdatedPkg, dependentPkgs: [] };
+            }
+            outdatedMap[key].dependentPkgs.push({ location: rootDir, manifest });
+        }
+    }
+    let output;
+    switch (opts.format ?? 'table') {
+        case 'table': {
+            output = renderOutdatedTable(outdatedMap, opts);
+            break;
+        }
+        case 'list': {
+            output = renderOutdatedList(outdatedMap, opts);
+            break;
+        }
+        case 'json': {
+            output = renderOutdatedJSON(outdatedMap, opts);
+            break;
+        }
+        default: {
+            throw new PnpmError('BAD_OUTDATED_FORMAT', `Unsupported format: ${opts.format?.toString() ?? 'undefined'}`);
+        }
+    }
+    return {
+        output,
+        exitCode: isEmpty(outdatedMap) ? 0 : 1,
+    };
+}
+function renderOutdatedTable(outdatedMap, opts) {
+    if (isEmpty(outdatedMap))
+        return '';
+    const columnNames = [
+        'Package',
+        'Current',
+        'Latest',
+        'Dependents',
+    ];
+    const columnFns = [
+        renderPackageName,
+        renderCurrent,
+        renderLatest,
+        dependentPackages,
+    ];
+    if (opts.long) {
+        columnNames.push('Details');
+        columnFns.push(renderDetails);
+    }
+    // Avoid the overhead of allocating a new array caused by calling `array.map()`
+    for (let i = 0; i < columnNames.length; i++)
+        columnNames[i] = chalk.blueBright(columnNames[i]);
+    const data = [
+        columnNames,
+        ...sortOutdatedPackages(Object.values(outdatedMap))
+            .map((outdatedPkg) => columnFns.map((fn) => fn(outdatedPkg))),
+    ];
+    return table(data, {
+        ...TABLE_OPTIONS,
+        columns: {
+            ...TABLE_OPTIONS.columns,
+            // Dependents column:
+            3: {
+                width: getCellWidth(data, 3, 30),
+                wrapWord: true,
+            },
+        },
+    });
+}
+function renderOutdatedList(outdatedMap, opts) {
+    if (isEmpty(outdatedMap))
+        return '';
+    return sortOutdatedPackages(Object.values(outdatedMap))
+        .map((outdatedPkg) => {
+        let info = `${chalk.bold(renderPackageName(outdatedPkg))}
+${renderCurrent(outdatedPkg)} ${chalk.grey('=>')} ${renderLatest(outdatedPkg)}`;
+        const dependents = dependentPackages(outdatedPkg);
+        if (dependents) {
+            info += `\n${chalk.bold(outdatedPkg.dependentPkgs.length > 1
+                ? 'Dependents:'
+                : 'Dependent:')} ${dependents}`;
+        }
+        if (opts.long) {
+            const details = renderDetails(outdatedPkg);
+            if (details) {
+                info += `\n${details}`;
+            }
+        }
+        return info;
+    })
+        .join('\n\n') + '\n';
+}
+function renderOutdatedJSON(outdatedMap, opts) {
+    const outdatedPackagesJSON = sortOutdatedPackages(Object.values(outdatedMap))
+        .reduce((acc, outdatedPkg) => {
+        acc[outdatedPkg.packageName] = {
+            current: outdatedPkg.current,
+            latest: outdatedPkg.latestManifest?.version,
+            wanted: outdatedPkg.wanted,
+            isDeprecated: Boolean(outdatedPkg.latestManifest?.deprecated),
+            dependencyType: outdatedPkg.belongsTo,
+            dependentPackages: outdatedPkg.dependentPkgs.map(({ manifest, location }) => ({ name: manifest.name, location })),
+        };
+        if (opts.long) {
+            acc[outdatedPkg.packageName].latestManifest = outdatedPkg.latestManifest;
+        }
+        return acc;
+    }, {});
+    return JSON.stringify(outdatedPackagesJSON, null, 2);
+}
+function dependentPackages({ dependentPkgs }) {
+    return dependentPkgs
+        .map(({ manifest, location }) => manifest.name ?? location)
+        .sort()
+        .join(', ');
+}
+function sortOutdatedPackages(outdatedPackages) {
+    return sortWith(COMPARATORS, outdatedPackages.map(toOutdatedWithVersionDiff));
+}
+//# sourceMappingURL=recursive.js.map

package/lib/outdated/utils.d.ts

@@ -0,0 +1,13 @@
+import type { OutdatedPackage } from '@pnpm/deps.inspection.outdated';
+import type { SEMVER_CHANGE } from '@pnpm/semver-diff';
+export interface OutdatedWithVersionDiff extends OutdatedPackage {
+    change: SEMVER_CHANGE | null;
+    diff?: [string[], string[]];
+}
+export type Comparator = (o1: OutdatedWithVersionDiff, o2: OutdatedWithVersionDiff) => number;
+export declare const NAME_COMPARATOR: Comparator;
+/**
+ * Default comparators used as the argument to `ramda.sortWith()`.
+ */
+export declare const DEFAULT_COMPARATORS: Comparator[];
+export declare function sortBySemverChange(outdated1: OutdatedWithVersionDiff, outdated2: OutdatedWithVersionDiff): number;

package/lib/outdated/utils.js

@@ -0,0 +1,22 @@
+export const NAME_COMPARATOR = (o1, o2) => o1.packageName.localeCompare(o2.packageName);
+/**
+ * Default comparators used as the argument to `ramda.sortWith()`.
+ */
+export const DEFAULT_COMPARATORS = [
+    sortBySemverChange,
+    NAME_COMPARATOR,
+    (o1, o2) => (o1.current && o2.current) ? o1.current.localeCompare(o2.current) : 0, // eslint-disable-line @typescript-eslint/explicit-module-boundary-types
+];
+export function sortBySemverChange(outdated1, outdated2) {
+    return pkgPriority(outdated1) - pkgPriority(outdated2);
+}
+function pkgPriority(pkg) {
+    switch (pkg.change) {
+        case null: return 0;
+        case 'fix': return 1;
+        case 'feature': return 2;
+        case 'breaking': return 3;
+        default: return 4;
+    }
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@pnpm/deps.inspection.commands",
+  "version": "1000.0.0",
+  "description": "The list, ll, why, and outdated commands of pnpm",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/deps/inspection/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/deps/inspection/commands#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/colorize-semver-diff": "^1.0.1",
+    "@pnpm/semver-diff": "^1.1.0",
+    "@zkochan/table": "^2.0.1",
+    "chalk": "^5.6.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "render-help": "^2.0.0",
+    "@pnpm/cli.common-cli-options-help": "1000.0.1",
+    "@pnpm/cli.command": "1000.0.0",
+    "@pnpm/cli.utils": "1001.2.8",
+    "@pnpm/config.reader": "1004.4.2",
+    "@pnpm/deps.inspection.outdated": "1001.1.1",
+    "@pnpm/deps.inspection.list": "1000.1.3",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/config.matcher": "1000.1.0",
+    "@pnpm/global.commands": "1000.0.0-0",
+    "@pnpm/global.packages": "1000.0.0-0",
+    "@pnpm/installing.modules-yaml": "1000.3.6",
+    "@pnpm/resolving.default-resolver": "1002.2.12",
+    "@pnpm/store.path": "1000.0.5",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/lockfile.fs": "1001.1.21"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@pnpm/registry-mock": "5.2.4",
+    "@types/ramda": "0.29.12",
+    "@types/zkochan__table": "npm:@types/table@6.0.0",
+    "execa": "npm:safe-execa@0.3.0",
+    "symlink-dir": "^7.0.0",
+    "write-yaml-file": "^6.0.0",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/prepare": "1000.0.4",
+    "@pnpm/installing.commands": "1004.6.10",
+    "@pnpm/test-fixtures": "1000.0.0",
+    "@pnpm/deps.inspection.commands": "1000.0.0",
+    "@pnpm/workspace.projects-filter": "1000.0.43"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config/with-registry"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}