@pnpm/cli.default-reporter 1002.0.11

package/lib/reportError.js

@@ -0,0 +1,425 @@
+import { renderDedupeCheckIssues } from '@pnpm/installing.dedupe.issues-renderer';
+import { renderPeerIssues } from '@pnpm/installing.render-peer-issues';
+import chalk from 'chalk';
+import { equals } from 'ramda';
+import StackTracey from 'stacktracey';
+import { EOL } from './constants.js';
+StackTracey.maxColumnWidths = {
+    callee: 25,
+    file: 350,
+    sourceLine: 25,
+};
+const highlight = chalk.yellow;
+const colorPath = chalk.gray;
+export function reportError(logObj, config) {
+    const errorInfo = getErrorInfo(logObj, config);
+    if (!errorInfo)
+        return null;
+    let output = formatErrorSummary(errorInfo.title, logObj.err?.code);
+    if (logObj.pkgsStack != null) {
+        if (logObj.pkgsStack.length > 0) {
+            output += `\n\n${formatPkgsStack(logObj.pkgsStack)}`;
+        }
+        else if ('prefix' in logObj && logObj.prefix) {
+            output += `\n\nThis error happened while installing a direct dependency of ${logObj.prefix}`;
+        }
+    }
+    if (errorInfo.body) {
+        output += `\n\n${errorInfo.body}`;
+    }
+    return output;
+}
+function getErrorInfo(logObj, config) {
+    if ('err' in logObj && logObj.err) {
+        const err = logObj.err;
+        switch (err.code) {
+            case 'ERR_PNPM_UNEXPECTED_STORE':
+                return reportUnexpectedStore(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_UNEXPECTED_VIRTUAL_STORE':
+                return reportUnexpectedVirtualStoreDir(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_STORE_BREAKING_CHANGE':
+                return reportStoreBreakingChange(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_MODULES_BREAKING_CHANGE':
+                return reportModulesBreakingChange(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_MODIFIED_DEPENDENCY':
+                return reportModifiedDependency(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_LOCKFILE_BREAKING_CHANGE':
+                return reportLockfileBreakingChange(err, logObj);
+            case 'ERR_PNPM_RECURSIVE_RUN_NO_SCRIPT':
+                return { title: err.message };
+            case 'ERR_PNPM_MISSING_TIME':
+                return { title: err.message, body: 'If you cannot fix this registry issue, then set "resolution-mode" to "highest".' };
+            case 'ERR_PNPM_NO_MATCHING_VERSION':
+            case 'ERR_PNPM_NO_MATURE_MATCHING_VERSION':
+                return formatNoMatchingVersion(err, logObj);
+            case 'ERR_PNPM_RECURSIVE_FAIL':
+                return formatRecursiveCommandSummary(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_BAD_TARBALL_SIZE':
+                return reportBadTarballSize(err, logObj);
+            case 'ELIFECYCLE':
+                return reportLifecycleError(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_UNSUPPORTED_ENGINE':
+                return reportEngineError(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_PEER_DEP_ISSUES':
+                return reportPeerDependencyIssuesError(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_DEDUPE_CHECK_ISSUES':
+                return reportDedupeCheckIssuesError(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_SPEC_NOT_SUPPORTED_BY_ANY_RESOLVER':
+                return reportSpecNotSupportedByAnyResolverError(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_FETCH_401':
+            case 'ERR_PNPM_FETCH_403':
+                return reportAuthError(err, logObj, config); // eslint-disable-line @typescript-eslint/no-explicit-any
+            default: {
+                // Errors with unknown error codes are printed with stack trace
+                if (!err.code?.startsWith?.('ERR_PNPM_')) {
+                    return formatGenericError(err.message ?? logObj.message, err.stack);
+                }
+                return {
+                    title: err.message ?? '',
+                    body: logObj.hint,
+                };
+            }
+        }
+    }
+    return { title: logObj.message };
+}
+function formatPkgNameVer({ name, version }) {
+    return version == null
+        ? name
+        : `${name}@${version}`;
+}
+function formatPkgsStack(pkgsStack) {
+    return `This error happened while installing the dependencies of \
+${formatPkgNameVer(pkgsStack[0])}\
+${pkgsStack.slice(1).map((pkgInfo) => `${EOL} at ${formatPkgNameVer(pkgInfo)}`).join('')}`;
+}
+function formatNoMatchingVersion(err, msg) {
+    const meta = msg.packageMeta;
+    const latestVersion = meta['dist-tags'].latest;
+    let output = `The latest release of ${meta.name} is "${latestVersion}".`;
+    const latestTime = msg.packageMeta.time?.[latestVersion];
+    if (latestTime) {
+        output += ` Published at ${stringifyDate(latestTime)}`;
+    }
+    output += EOL;
+    if (!equals(Object.keys(meta['dist-tags']), ['latest'])) {
+        output += EOL + 'Other releases are:' + EOL;
+        for (const tag in meta['dist-tags']) {
+            if (tag !== 'latest') {
+                const version = meta['dist-tags'][tag];
+                output += `  * ${tag}: ${version}`;
+                const time = msg.packageMeta.time?.[version];
+                if (time) {
+                    output += ` published at ${stringifyDate(time)}`;
+                }
+                output += EOL;
+            }
+        }
+    }
+    output += `${EOL}If you need the full list of all ${Object.keys(meta.versions).length} published versions run "pnpm view ${meta.name} versions".`;
+    if (msg.immatureVersion) {
+        output += `${EOL}${EOL}If you want to install the matched version ignoring the time it was published, you can add the package name to the minimumReleaseAgeExclude setting. Read more about it: https://pnpm.io/settings#minimumreleaseageexclude`;
+    }
+    return {
+        title: err.message,
+        body: output,
+    };
+}
+function stringifyDate(dateStr) {
+    const now = Date.now();
+    const oneDayAgo = now - 24 * 60 * 60 * 1000;
+    const date = new Date(dateStr);
+    if (date.getTime() < oneDayAgo) {
+        return date.toLocaleDateString();
+    }
+    return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+}
+function reportUnexpectedStore(err, msg) {
+    return {
+        title: err.message,
+        body: `The dependencies at "${msg.modulesDir}" are currently linked from the store at "${msg.expectedStorePath}".
+
+pnpm now wants to use the store at "${msg.actualStorePath}" to link dependencies.
+
+If you want to use the new store location, reinstall your dependencies with "pnpm install".
+
+You may change the global store location by running "pnpm config set store-dir <dir> --global".
+(This error may happen if the node_modules was installed with a different major version of pnpm)`,
+    };
+}
+function reportUnexpectedVirtualStoreDir(err, msg) {
+    return {
+        title: err.message,
+        body: `The dependencies at "${msg.modulesDir}" are currently symlinked from the virtual store directory at "${msg.expected}".
+
+pnpm now wants to use the virtual store at "${msg.actual}" to link dependencies from the store.
+
+If you want to use the new virtual store location, reinstall your dependencies with "pnpm install".
+
+You may change the virtual store location by changing the value of the virtual-store-dir config.`,
+    };
+}
+function reportStoreBreakingChange(msg) {
+    let output = `Store path: ${colorPath(msg.storePath)}
+
+Run "pnpm install" to recreate node_modules.`;
+    if (msg.additionalInformation) {
+        output = `${output}${EOL}${EOL}${msg.additionalInformation}`;
+    }
+    output += formatRelatedSources(msg);
+    return {
+        title: 'The store used for the current node_modules is incompatible with the current version of pnpm',
+        body: output,
+    };
+}
+function reportModulesBreakingChange(msg) {
+    let output = `node_modules path: ${colorPath(msg.modulesPath)}
+
+Run ${highlight('pnpm install')} to recreate node_modules.`;
+    if (msg.additionalInformation) {
+        output = `${output}${EOL}${EOL}${msg.additionalInformation}`;
+    }
+    output += formatRelatedSources(msg);
+    return {
+        title: 'The current version of pnpm is not compatible with the available node_modules structure',
+        body: output,
+    };
+}
+function formatRelatedSources(msg) {
+    let output = '';
+    if (!msg.relatedIssue && !msg.relatedPR)
+        return output;
+    output += EOL;
+    if (msg.relatedIssue) {
+        output += EOL + `Related issue: ${colorPath(`https://github.com/pnpm/pnpm/issues/${msg.relatedIssue}`)}`;
+    }
+    if (msg.relatedPR) {
+        output += EOL + `Related PR: ${colorPath(`https://github.com/pnpm/pnpm/pull/${msg.relatedPR}`)}`;
+    }
+    return output;
+}
+function formatGenericError(errorMessage, stack) {
+    if (stack) {
+        let prettyStack;
+        try {
+            prettyStack = new StackTracey(stack).asTable();
+        }
+        catch {
+            prettyStack = stack.toString();
+        }
+        if (prettyStack) {
+            return {
+                title: errorMessage,
+                body: prettyStack,
+            };
+        }
+    }
+    return { title: errorMessage };
+}
+function formatErrorSummary(message, code) {
+    return `${chalk.bgRed.black(`\u2009${code ?? 'ERROR'}\u2009`)} ${chalk.red(message)}`;
+}
+function reportModifiedDependency(msg) {
+    return {
+        title: 'Packages in the store have been mutated',
+        body: `These packages are modified:
+${msg.modified.map((pkgPath) => colorPath(pkgPath)).join(EOL)}
+
+You can run ${highlight('pnpm install --force')} to refetch the modified packages`,
+    };
+}
+function reportLockfileBreakingChange(err, _msg) {
+    return {
+        title: err.message,
+        body: `Run with the ${highlight('--force')} parameter to recreate the lockfile.`,
+    };
+}
+function formatRecursiveCommandSummary(msg) {
+    const output = EOL + `Summary: ${chalk.red(`${msg.failures.length} fails`)}, ${msg.passes} passes` + EOL + EOL +
+        msg.failures.map(({ message, prefix }) => {
+            return prefix + ':' + EOL + formatErrorSummary(message);
+        }).join(EOL + EOL);
+    return {
+        title: '',
+        body: output,
+    };
+}
+function reportBadTarballSize(err, _msg) {
+    return {
+        title: err.message,
+        body: `Seems like you have internet connection issues.
+Try running the same command again.
+If that doesn't help, try one of the following:
+
+- Set a bigger value for the \`fetch-retries\` config.
+    To check the current value of \`fetch-retries\`, run \`pnpm get fetch-retries\`.
+    To set a new value, run \`pnpm set fetch-retries <number>\`.
+
+- Set \`network-concurrency\` to 1.
+    This change will slow down installation times, so it is recommended to
+    delete the config once the internet connection is good again: \`pnpm config delete network-concurrency\`
+
+NOTE: You may also override configs via flags.
+For instance, \`pnpm install --fetch-retries 5 --network-concurrency 1\``,
+    };
+}
+function reportLifecycleError(msg) {
+    if (msg.stage === 'test') {
+        return { title: 'Test failed. See above for more details.' };
+    }
+    if (typeof msg.errno === 'number') {
+        return { title: `Command failed with exit code ${msg.errno}.` };
+    }
+    return { title: 'Command failed.' };
+}
+function reportEngineError(msg) {
+    let output = '';
+    if (msg.wanted.pnpm) {
+        output += `\
+Your pnpm version is incompatible with "${msg.packageId}".
+
+Expected version: ${msg.wanted.pnpm}
+Got: ${msg.current.pnpm}
+
+This is happening because the package's manifest has an engines.pnpm field specified.
+To fix this issue, install the required pnpm version globally.
+
+To install the latest version of pnpm, run "pnpm i -g pnpm".
+To check your pnpm version, run "pnpm -v".`;
+    }
+    if (msg.wanted.node) {
+        if (output)
+            output += EOL + EOL;
+        output += `\
+Your Node version is incompatible with "${msg.packageId}".
+
+Expected version: ${msg.wanted.node}
+Got: ${msg.current.node}
+
+This is happening because the package's manifest has an engines.node field specified.
+To fix this issue, install the required Node version.`;
+    }
+    return {
+        title: 'Unsupported environment (bad pnpm and/or Node.js version)',
+        body: output,
+    };
+}
+function reportAuthError(err, msg, config) {
+    const foundSettings = [];
+    for (const [key, value] of Object.entries(config?.rawConfig ?? {})) {
+        if (key[0] === '@') {
+            foundSettings.push(`${key}=${String(value)}`);
+            continue;
+        }
+        if (key.endsWith('_auth') ||
+            key.endsWith('_authToken') ||
+            key.endsWith('username') ||
+            key.endsWith('_password')) {
+            foundSettings.push(`${key}=${hideSecureInfo(key, value)}`);
+        }
+    }
+    let output = msg.hint ? `${msg.hint}${EOL}${EOL}` : '';
+    if (foundSettings.length === 0) {
+        output += `No authorization settings were found in the configs.
+Try to log in to the registry by running "pnpm login"
+or add the auth tokens manually to the ~/.npmrc file.`;
+    }
+    else {
+        output += `These authorization settings were found:
+${foundSettings.join('\n')}`;
+    }
+    return {
+        title: err.message,
+        body: output,
+    };
+}
+function hideSecureInfo(key, value) {
+    if (key.endsWith('_password'))
+        return '[hidden]';
+    if (key.endsWith('_auth') || key.endsWith('_authToken'))
+        return `${value.substring(0, 4)}[hidden]`;
+    return value;
+}
+function reportPeerDependencyIssuesError(err, msg) {
+    const hasMissingPeers = getHasMissingPeers(msg.issuesByProjects);
+    const hints = [];
+    if (hasMissingPeers) {
+        hints.push(`To auto-install peer dependencies, add the following to "pnpm-workspace.yaml" in your project root:
+
+  autoInstallPeers: true`);
+    }
+    hints.push(`To disable failing on peer dependency issues, add the following to pnpm-workspace.yaml in your project root:
+
+  strictPeerDependencies: false
+`);
+    const rendered = renderPeerIssues(msg.issuesByProjects);
+    if (!rendered) {
+        // This should never happen.
+        return {
+            title: err.message,
+        };
+    }
+    return {
+        title: err.message,
+        body: `${rendered}
+${hints.map((hint) => `hint: ${hint}`).join('\n')}
+`,
+    };
+}
+function getHasMissingPeers(issuesByProjects) {
+    return Object.values(issuesByProjects)
+        .some((issues) => Object.values(issues.missing).flat().some(({ optional }) => !optional));
+}
+function reportDedupeCheckIssuesError(err, msg) {
+    return {
+        title: err.message,
+        body: `\
+${renderDedupeCheckIssues(msg.dedupeCheckIssues)}
+Run ${chalk.yellow('pnpm dedupe')} to apply the changes above.
+`,
+    };
+}
+function reportSpecNotSupportedByAnyResolverError(err, logObj) {
+    // If the catalog protocol specifier was sent to a "real resolver", it'll
+    // eventually throw a "specifier not supported" error since the catalog
+    // protocol is meant to be replaced before it's passed to any of the real
+    // resolvers.
+    //
+    // If this kind of error is thrown, and the dependency bareSpecifier is using the
+    // catalog protocol it's most likely because we're trying to install an out of
+    // repo dependency that was published incorrectly. For example, it may be been
+    // mistakenly published with 'npm publish' instead of 'pnpm publish'. Report a
+    // more clear error in this case.
+    if (logObj.package?.bareSpecifier?.startsWith('catalog:')) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return reportExternalCatalogProtocolError(err, logObj);
+    }
+    return {
+        title: err.message ?? '',
+        body: logObj.hint,
+    };
+}
+function reportExternalCatalogProtocolError(err, logObj) {
+    const { pkgsStack } = logObj;
+    const problemDep = pkgsStack?.[0];
+    let body = `\
+An external package outside of the pnpm workspace declared a dependency using
+the catalog protocol. This is likely a bug in that external package. Only
+packages within the pnpm workspace may use catalogs. Usages of the catalog
+protocol are replaced with real specifiers on 'pnpm publish'.
+`;
+    if (problemDep != null) {
+        body += `\
+
+This is likely a bug in the publishing automation of this package. Consider filing
+a bug with the authors of:
+
+  ${highlight(formatPkgNameVer(problemDep))}
+`;
+    }
+    return {
+        title: err.message,
+        body,
+    };
+}
+//# sourceMappingURL=reportError.js.map

package/lib/reporterForClient/index.d.ts

@@ -0,0 +1,52 @@
+import type { Config } from '@pnpm/config.reader';
+import type * as logs from '@pnpm/core-loggers';
+import type { LogLevel } from '@pnpm/logger';
+import type * as Rx from 'rxjs';
+import { type FilterPkgsDiff } from './reportSummary.js';
+export declare function reporterForClient(log$: {
+    context: Rx.Observable<logs.ContextLog>;
+    fetchingProgress: Rx.Observable<logs.FetchingProgressLog>;
+    executionTime: Rx.Observable<logs.ExecutionTimeLog>;
+    ignoredScripts: Rx.Observable<logs.IgnoredScriptsLog>;
+    progress: Rx.Observable<logs.ProgressLog>;
+    stage: Rx.Observable<logs.StageLog>;
+    deprecation: Rx.Observable<logs.DeprecationLog>;
+    summary: Rx.Observable<logs.SummaryLog>;
+    lifecycle: Rx.Observable<logs.LifecycleLog>;
+    stats: Rx.Observable<logs.StatsLog>;
+    installCheck: Rx.Observable<logs.InstallCheckLog>;
+    installingConfigDeps: Rx.Observable<logs.InstallingConfigDepsLog>;
+    registry: Rx.Observable<logs.RegistryLog>;
+    root: Rx.Observable<logs.RootLog>;
+    packageManifest: Rx.Observable<logs.PackageManifestLog>;
+    peerDependencyIssues: Rx.Observable<logs.PeerDependencyIssuesLog>;
+    requestRetry: Rx.Observable<logs.RequestRetryLog>;
+    link: Rx.Observable<logs.LinkLog>;
+    other: Rx.Observable<logs.Log>;
+    hook: Rx.Observable<logs.HookLog>;
+    scope: Rx.Observable<logs.ScopeLog>;
+    skippedOptionalDependency: Rx.Observable<logs.SkippedOptionalDependencyLog>;
+    packageImportMethod: Rx.Observable<logs.PackageImportMethodLog>;
+    updateCheck: Rx.Observable<logs.UpdateCheckLog>;
+}, opts: {
+    appendOnly?: boolean;
+    cmd: string;
+    config?: Config;
+    env: NodeJS.ProcessEnv;
+    filterPkgsDiff?: FilterPkgsDiff;
+    process: NodeJS.Process;
+    isRecursive: boolean;
+    logLevel?: LogLevel;
+    pnpmConfig?: Config;
+    streamLifecycleOutput?: boolean;
+    aggregateOutput?: boolean;
+    throttleProgress?: number;
+    width?: number;
+    hideAddedPkgsProgress?: boolean;
+    hideProgressPrefix?: boolean;
+    hideLifecycleOutput?: boolean;
+    hideLifecyclePrefix?: boolean;
+    approveBuildsInstructionText?: string;
+}): Array<Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>>;

package/lib/reporterForClient/index.js

@@ -0,0 +1,94 @@
+import { throttleTime } from 'rxjs/operators';
+import { reportBigTarballProgress } from './reportBigTarballsProgress.js';
+import { reportContext } from './reportContext.js';
+import { reportDeprecations } from './reportDeprecations.js';
+import { reportExecutionTime } from './reportExecutionTime.js';
+import { reportHooks } from './reportHooks.js';
+import { reportIgnoredBuilds } from './reportIgnoredBuilds.js';
+import { reportInstallChecks } from './reportInstallChecks.js';
+import { reportInstallingConfigDeps } from './reportInstallingConfigDeps.js';
+import { reportLifecycleScripts } from './reportLifecycleScripts.js';
+import { LOG_LEVEL_NUMBER, reportMisc } from './reportMisc.js';
+import { reportPeerDependencyIssues } from './reportPeerDependencyIssues.js';
+import { reportProgress } from './reportProgress.js';
+import { reportRequestRetry } from './reportRequestRetry.js';
+import { reportScope } from './reportScope.js';
+import { reportSkippedOptionalDependencies } from './reportSkippedOptionalDependencies.js';
+import { reportStats } from './reportStats.js';
+import { reportSummary } from './reportSummary.js';
+import { reportUpdateCheck } from './reportUpdateCheck.js';
+const PRINT_EXECUTION_TIME_IN_COMMANDS = {
+    install: true,
+    update: true,
+    add: true,
+    remove: true,
+};
+export function reporterForClient(log$, opts) {
+    const width = opts.width ?? process.stdout.columns ?? 80;
+    const cwd = opts.pnpmConfig?.dir ?? process.cwd();
+    const throttle = typeof opts.throttleProgress === 'number' && opts.throttleProgress > 0
+        ? throttleTime(opts.throttleProgress, undefined, { leading: true, trailing: true })
+        : undefined;
+    const outputs = [
+        reportMisc(log$, {
+            appendOnly: opts.appendOnly === true,
+            config: opts.config,
+            cwd,
+            logLevel: opts.logLevel,
+            zoomOutCurrent: opts.isRecursive,
+        }),
+    ];
+    // logLevelNumber: 0123 = error warn info debug
+    const logLevelNumber = LOG_LEVEL_NUMBER[opts.logLevel ?? 'info'] ?? LOG_LEVEL_NUMBER['info'];
+    const showInfo = logLevelNumber >= LOG_LEVEL_NUMBER.info;
+    if (logLevelNumber >= LOG_LEVEL_NUMBER.warn) {
+        outputs.push(reportPeerDependencyIssues(log$), reportDeprecations({
+            deprecation: log$.deprecation,
+            stage: log$.stage,
+        }, { cwd, isRecursive: opts.isRecursive }), reportRequestRetry(log$.requestRetry));
+    }
+    if (showInfo) {
+        if (opts.cmd in PRINT_EXECUTION_TIME_IN_COMMANDS) {
+            outputs.push(reportExecutionTime(log$.executionTime));
+        }
+        if (opts.cmd !== 'dlx') {
+            outputs.push(reportContext(log$, { cwd }));
+        }
+        outputs.push(reportLifecycleScripts(log$, {
+            appendOnly: (opts.appendOnly === true || opts.streamLifecycleOutput) && !opts.hideLifecycleOutput,
+            aggregateOutput: opts.aggregateOutput,
+            hideLifecyclePrefix: opts.hideLifecyclePrefix,
+            cwd,
+            width,
+        }), reportInstallChecks(log$.installCheck, { cwd }), reportInstallingConfigDeps(log$.installingConfigDeps), reportScope(log$.scope, { isRecursive: opts.isRecursive, cmd: opts.cmd }), reportSkippedOptionalDependencies(log$.skippedOptionalDependency, { cwd }), reportHooks(log$.hook, { cwd, isRecursive: opts.isRecursive }), reportUpdateCheck(log$.updateCheck, opts), reportProgress(log$, {
+            cwd,
+            throttle,
+            hideAddedPkgsProgress: opts.hideAddedPkgsProgress,
+            hideProgressPrefix: opts.hideProgressPrefix,
+        }), ...reportStats(log$, {
+            cmd: opts.cmd,
+            cwd,
+            isRecursive: opts.isRecursive,
+            width,
+            hideProgressPrefix: opts.hideProgressPrefix,
+        }));
+        if (!opts.appendOnly) {
+            outputs.push(reportBigTarballProgress(log$));
+        }
+        if (!opts.isRecursive) {
+            outputs.push(reportSummary(log$, {
+                cmd: opts.cmd,
+                cwd,
+                env: opts.env,
+                filterPkgsDiff: opts.filterPkgsDiff,
+                pnpmConfig: opts.pnpmConfig,
+            }));
+        }
+        outputs.push(reportIgnoredBuilds(log$, {
+            pnpmConfig: opts.pnpmConfig,
+            approveBuildsInstructionText: opts.approveBuildsInstructionText,
+        }));
+    }
+    return outputs;
+}
+//# sourceMappingURL=index.js.map

package/lib/reporterForClient/outputConstants.d.ts

@@ -0,0 +1,4 @@
+export declare const PREFIX_MAX_LENGTH = 40;
+export declare const hlValue: import("chalk").ChalkInstance;
+export declare const ADDED_CHAR: string;
+export declare const REMOVED_CHAR: string;

package/lib/reporterForClient/outputConstants.js

@@ -0,0 +1,6 @@
+import chalk from 'chalk';
+export const PREFIX_MAX_LENGTH = 40;
+export const hlValue = chalk.cyanBright;
+export const ADDED_CHAR = chalk.green('+');
+export const REMOVED_CHAR = chalk.red('-');
+//# sourceMappingURL=outputConstants.js.map

package/lib/reporterForClient/pkgsDiff.d.ts

@@ -0,0 +1,36 @@
+import type * as logs from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export interface PackageDiff {
+    added: boolean;
+    from?: string;
+    name: string;
+    realName?: string;
+    version?: string;
+    deprecated?: boolean;
+    latest?: string;
+}
+export interface RecordByString<T> {
+    [index: string]: T;
+}
+export declare const propertyByDependencyType: {
+    readonly dev: "devDependencies";
+    readonly nodeModulesOnly: "node_modules";
+    readonly optional: "optionalDependencies";
+    readonly peer: "peerDependencies";
+    readonly prod: "dependencies";
+};
+export interface PkgsDiff {
+    dev: RecordByString<PackageDiff>;
+    nodeModulesOnly: RecordByString<PackageDiff>;
+    optional: RecordByString<PackageDiff>;
+    peer: RecordByString<PackageDiff>;
+    prod: RecordByString<PackageDiff>;
+}
+export declare function getPkgsDiff(log$: {
+    deprecation: Rx.Observable<logs.DeprecationLog>;
+    summary: Rx.Observable<logs.SummaryLog>;
+    root: Rx.Observable<logs.RootLog>;
+    packageManifest: Rx.Observable<logs.PackageManifestLog>;
+}, opts: {
+    prefix?: string;
+}): Rx.Observable<PkgsDiff>;