@pnpm/cli.default-reporter 1002.0.11

package/lib/reporterForClient/pkgsDiff.js

@@ -0,0 +1,113 @@
+import { difference, mergeRight } from 'ramda';
+import * as Rx from 'rxjs';
+import { filter, map, mapTo, reduce, scan, startWith, take } from 'rxjs/operators';
+export const propertyByDependencyType = {
+    dev: 'devDependencies',
+    nodeModulesOnly: 'node_modules',
+    optional: 'optionalDependencies',
+    peer: 'peerDependencies',
+    prod: 'dependencies',
+};
+export function getPkgsDiff(log$, opts) {
+    const deprecationSet$ = log$.deprecation
+        .pipe(filter((log) => !opts.prefix || log.prefix === opts.prefix), scan((acc, log) => {
+        acc.add(log.pkgId);
+        return acc;
+    }, new Set()), startWith(new Set()));
+    const filterPrefix = opts.prefix
+        ? filter((log) => log.prefix === opts.prefix)
+        : (x) => x;
+    const pkgsDiff$ = Rx.combineLatest(log$.root.pipe(filterPrefix), deprecationSet$).pipe(scan((pkgsDiff, args) => {
+        const rootLog = args[0];
+        const deprecationSet = args[1];
+        let action;
+        let log; // eslint-disable-line
+        if ('added' in rootLog) {
+            action = '+';
+            log = rootLog['added'];
+        }
+        else if ('removed' in rootLog) {
+            action = '-';
+            log = rootLog['removed'];
+        }
+        else {
+            return pkgsDiff;
+        }
+        const depType = (log.dependencyType || 'nodeModulesOnly');
+        const oppositeKey = `${action === '-' ? '+' : '-'}${log.name}`;
+        const previous = pkgsDiff[depType][oppositeKey];
+        if (previous && previous.version === log.version) {
+            delete pkgsDiff[depType][oppositeKey];
+            return pkgsDiff;
+        }
+        pkgsDiff[depType][`${action}${log.name}`] = {
+            added: action === '+',
+            deprecated: deprecationSet.has(log.id),
+            from: log.linkedFrom,
+            latest: log.latest,
+            name: log.name,
+            realName: log.realName,
+            version: log.version ?? log.id,
+        };
+        return pkgsDiff;
+    }, {
+        dev: {},
+        nodeModulesOnly: {},
+        optional: {},
+        peer: {},
+        prod: {},
+    }), startWith({
+        dev: {},
+        nodeModulesOnly: {},
+        optional: {},
+        peer: {},
+        prod: {},
+    }));
+    const packageManifest$ = Rx.merge(log$.packageManifest.pipe(filterPrefix), log$.summary.pipe(filterPrefix, mapTo({})))
+        .pipe(take(2), reduce(mergeRight, {}) // eslint-disable-line @typescript-eslint/no-explicit-any
+    );
+    return Rx.combineLatest(pkgsDiff$, packageManifest$)
+        .pipe(map(([pkgsDiff, packageManifests]) => {
+        if ((packageManifests['initial'] == null) || (packageManifests['updated'] == null))
+            return pkgsDiff;
+        const initialPackageManifest = removeOptionalFromProdDeps(packageManifests['initial']);
+        const updatedPackageManifest = removeOptionalFromProdDeps(packageManifests['updated']);
+        for (const depType of ['peer', 'prod', 'optional', 'dev']) {
+            const prop = propertyByDependencyType[depType];
+            const initialDeps = Object.keys(initialPackageManifest[prop] ?? {});
+            const updatedDeps = Object.keys(updatedPackageManifest[prop] ?? {});
+            const removedDeps = difference(initialDeps, updatedDeps);
+            for (const removedDep of removedDeps) {
+                if (!pkgsDiff[depType][`-${removedDep}`]) {
+                    pkgsDiff[depType][`-${removedDep}`] = {
+                        added: false,
+                        name: removedDep,
+                        version: initialPackageManifest[prop]?.[removedDep],
+                    };
+                }
+            }
+            const addedDeps = difference(updatedDeps, initialDeps);
+            for (const addedDep of addedDeps) {
+                if (!pkgsDiff[depType][`+${addedDep}`]) {
+                    pkgsDiff[depType][`+${addedDep}`] = {
+                        added: true,
+                        name: addedDep,
+                        version: updatedPackageManifest[prop]?.[addedDep],
+                    };
+                }
+            }
+        }
+        return pkgsDiff;
+    }));
+}
+function removeOptionalFromProdDeps(pkg) {
+    if ((pkg.dependencies == null) || (pkg.optionalDependencies == null))
+        return pkg;
+    for (const depName of Object.keys(pkg.dependencies)) {
+        if (pkg.optionalDependencies[depName]) {
+            delete pkg.dependencies[depName];
+        }
+    }
+    return pkg;
+}
+//# sourceMappingURL=pkgsDiff.js.map

package/lib/reporterForClient/reportBigTarballsProgress.d.ts

@@ -0,0 +1,8 @@
+import type { FetchingProgressLog } from '@pnpm/core-loggers';
+import type * as Rx from 'rxjs';
+export declare function reportBigTarballProgress(log$: {
+    fetchingProgress: Rx.Observable<FetchingProgressLog>;
+}): Rx.Observable<Rx.Observable<{
+    fixed: boolean;
+    msg: string;
+}>>;

package/lib/reporterForClient/reportBigTarballsProgress.js

@@ -0,0 +1,26 @@
+import prettyBytes from 'pretty-bytes';
+import { filter, map, startWith } from 'rxjs/operators';
+import { hlValue, } from './outputConstants.js';
+const BIG_TARBALL_SIZE = 1024 * 1024 * 5; // 5 MB
+const PRETTY_OPTS = {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+};
+export function reportBigTarballProgress(log$) {
+    return log$.fetchingProgress.pipe(filter((log) => log.status === 'started' &&
+        typeof log.size === 'number' && log.size >= BIG_TARBALL_SIZE &&
+        // When retrying the download, keep the existing progress line.
+        // Fixing issue: https://github.com/pnpm/pnpm/issues/1013
+        log.attempt === 1), map((startedLog) => {
+        const size = prettyBytes(startedLog.size ?? 0, PRETTY_OPTS);
+        return log$.fetchingProgress.pipe(filter((log) => log.status === 'in_progress' && log.packageId === startedLog['packageId']), map((log) => log.downloaded ?? 0), startWith(0), map((downloadedRaw) => {
+            const done = startedLog.size === downloadedRaw;
+            const downloaded = prettyBytes(downloadedRaw, PRETTY_OPTS);
+            return {
+                fixed: !done,
+                msg: `Downloading ${startedLog['packageId']}: ${hlValue(downloaded)}/${hlValue(size)}${done ? ', done' : ''}`,
+            };
+        }));
+    }));
+}
+//# sourceMappingURL=reportBigTarballsProgress.js.map

package/lib/reporterForClient/reportContext.d.ts

@@ -0,0 +1,10 @@
+import type { ContextLog, PackageImportMethodLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportContext(log$: {
+    context: Rx.Observable<ContextLog>;
+    packageImportMethod: Rx.Observable<PackageImportMethodLog>;
+}, opts: {
+    cwd: string;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportContext.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import normalize from 'normalize-path';
+import * as Rx from 'rxjs';
+import { map, take } from 'rxjs/operators';
+export function reportContext(log$, opts) {
+    return Rx.combineLatest(log$.context.pipe(take(1)), log$.packageImportMethod.pipe(take(1)))
+        .pipe(map(([context, packageImportMethod]) => {
+        if (context.currentLockfileExists) {
+            return Rx.NEVER;
+        }
+        let method;
+        switch (packageImportMethod.method) {
+            case 'copy':
+                method = 'copied';
+                break;
+            case 'clone':
+                method = 'cloned';
+                break;
+            case 'hardlink':
+                method = 'hard linked';
+                break;
+            default:
+                method = packageImportMethod.method;
+                break;
+        }
+        return Rx.of({
+            msg: `\
+Packages are ${method} from the content-addressable store to the virtual store.
+  Content-addressable store is at: ${context.storeDir}
+  Virtual store is at:             ${normalize(path.relative(opts.cwd, context.virtualStoreDir))}`,
+        });
+    }));
+}
+//# sourceMappingURL=reportContext.js.map

package/lib/reporterForClient/reportDeprecations.d.ts

@@ -0,0 +1,11 @@
+import type { DeprecationLog, StageLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportDeprecations(log$: {
+    deprecation: Rx.Observable<DeprecationLog>;
+    stage: Rx.Observable<StageLog>;
+}, opts: {
+    cwd: string;
+    isRecursive: boolean;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportDeprecations.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import * as Rx from 'rxjs';
+import { buffer, filter, map, switchMap } from 'rxjs/operators';
+import { formatWarn } from './utils/formatWarn.js';
+import { zoomOut } from './utils/zooming.js';
+export function reportDeprecations(log$, opts) {
+    const [deprecatedDirectDeps$, deprecatedSubdeps$] = Rx.partition(log$.deprecation, (log) => log.depth === 0);
+    const resolutionDone$ = log$.stage.pipe(filter((log) => log.stage === 'resolution_done'));
+    return Rx.merge(deprecatedDirectDeps$.pipe(map((log) => {
+        if (!opts.isRecursive && log.prefix === opts.cwd) {
+            return Rx.of({
+                msg: formatWarn(`${chalk.red('deprecated')} ${log.pkgName}@${log.pkgVersion}: ${log.deprecated}`),
+            });
+        }
+        return Rx.of({
+            msg: zoomOut(opts.cwd, log.prefix, formatWarn(`${chalk.red('deprecated')} ${log.pkgName}@${log.pkgVersion}`)),
+        });
+    })), deprecatedSubdeps$.pipe(buffer(resolutionDone$), switchMap(deprecatedSubdeps => {
+        if (deprecatedSubdeps.length > 0) {
+            return Rx.of(Rx.of({
+                msg: formatWarn(`${chalk.red(`${deprecatedSubdeps.length} deprecated subdependencies found:`)} ${deprecatedSubdeps.map(log => `${log.pkgName}@${log.pkgVersion}`).sort().join(', ')}`),
+            }));
+        }
+        return Rx.EMPTY;
+    })));
+}
+//# sourceMappingURL=reportDeprecations.js.map

package/lib/reporterForClient/reportExecutionTime.d.ts

@@ -0,0 +1,6 @@
+import type { ExecutionTimeLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportExecutionTime(executionTime$: Rx.Observable<ExecutionTimeLog>): Rx.Observable<Rx.Observable<{
+    fixed: boolean;
+    msg: string;
+}>>;

package/lib/reporterForClient/reportExecutionTime.js

@@ -0,0 +1,13 @@
+import { packageManager } from '@pnpm/cli.meta';
+import prettyMs from 'pretty-ms';
+import * as Rx from 'rxjs';
+import { map, take } from 'rxjs/operators';
+export function reportExecutionTime(executionTime$) {
+    return executionTime$.pipe(take(1), map((log) => {
+        return Rx.of({
+            fixed: true, // Without this, for some reason sometimes the progress bar is printed after the execution time
+            msg: `Done in ${prettyMs(log.endedAt - log.startedAt)} using ${packageManager.name} v${packageManager.version}`,
+        });
+    }));
+}
+//# sourceMappingURL=reportExecutionTime.js.map

package/lib/reporterForClient/reportHooks.d.ts

@@ -0,0 +1,8 @@
+import type { HookLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportHooks(hook$: Rx.Observable<HookLog>, opts: {
+    cwd: string;
+    isRecursive: boolean;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportHooks.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+import * as Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+import { autozoom } from './utils/zooming.js';
+export function reportHooks(hook$, opts) {
+    return hook$.pipe(map((log) => Rx.of({
+        msg: autozoom(opts.cwd, log.prefix, `${chalk.magentaBright(log.hook)}: ${log.message}`, {
+            zoomOutCurrent: opts.isRecursive,
+        }),
+    })));
+}
+//# sourceMappingURL=reportHooks.js.map

package/lib/reporterForClient/reportIgnoredBuilds.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from '@pnpm/config.reader';
+import type { IgnoredScriptsLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportIgnoredBuilds(log$: {
+    ignoredScripts: Rx.Observable<IgnoredScriptsLog>;
+}, opts: {
+    pnpmConfig?: Config;
+    approveBuildsInstructionText?: string;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportIgnoredBuilds.js

@@ -0,0 +1,21 @@
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import boxen from 'boxen';
+import * as Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+export function reportIgnoredBuilds(log$, opts) {
+    return log$.ignoredScripts.pipe(map((ignoredScripts) => {
+        if (ignoredScripts.packageNames && ignoredScripts.packageNames.length > 0 && !opts.pnpmConfig?.strictDepBuilds) {
+            const msg = boxen(`Ignored build scripts: ${Array.from(ignoredScripts.packageNames).sort(lexCompare).join(', ')}.
+${opts.approveBuildsInstructionText ?? `Run "pnpm approve-builds${opts.pnpmConfig?.cliOptions?.global ? ' -g' : ''}" to pick which dependencies should be allowed to run scripts.`}`, {
+                title: 'Warning',
+                padding: 1,
+                margin: 0,
+                borderStyle: 'round',
+                borderColor: 'yellow',
+            });
+            return Rx.of({ msg });
+        }
+        return Rx.NEVER;
+    }));
+}
+//# sourceMappingURL=reportIgnoredBuilds.js.map

package/lib/reporterForClient/reportInstallChecks.d.ts

@@ -0,0 +1,7 @@
+import type { InstallCheckLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportInstallChecks(installCheck$: Rx.Observable<InstallCheckLog>, opts: {
+    cwd: string;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportInstallChecks.js

@@ -0,0 +1,19 @@
+import * as Rx from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { formatWarn } from './utils/formatWarn.js';
+import { autozoom } from './utils/zooming.js';
+export function reportInstallChecks(installCheck$, opts) {
+    return installCheck$.pipe(map((log) => formatInstallCheck(opts.cwd, log)), filter(Boolean), map((msg) => Rx.of({ msg })));
+}
+function formatInstallCheck(currentPrefix, logObj, opts) {
+    const zoomOutCurrent = opts?.zoomOutCurrent ?? false;
+    switch (logObj.code) {
+        case 'EBADPLATFORM':
+            return autozoom(currentPrefix, logObj.prefix, formatWarn(`Unsupported system. Skipping dependency ${logObj.pkgId}`), { zoomOutCurrent });
+        case 'ENOTSUP':
+            return autozoom(currentPrefix, logObj.prefix, logObj.toString(), { zoomOutCurrent });
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=reportInstallChecks.js.map

package/lib/reporterForClient/reportInstallingConfigDeps.d.ts

@@ -0,0 +1,5 @@
+import type { InstallingConfigDepsLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportInstallingConfigDeps(installingConfigDeps$: Rx.Observable<InstallingConfigDepsLog>): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportInstallingConfigDeps.js

@@ -0,0 +1,18 @@
+import * as Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+export function reportInstallingConfigDeps(installingConfigDeps$) {
+    return Rx.of(installingConfigDeps$.pipe(map((log) => {
+        switch (log.status) {
+            case 'started': {
+                return {
+                    msg: 'Installing config dependencies...',
+                };
+            }
+            case 'done':
+                return {
+                    msg: `Installed config dependencies: ${log.deps.map(({ name, version }) => `${name}@${version}`).join(', ')}`,
+                };
+        }
+    })));
+}
+//# sourceMappingURL=reportInstallingConfigDeps.js.map

package/lib/reporterForClient/reportLifecycleScripts.d.ts

@@ -0,0 +1,13 @@
+import type { LifecycleLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportLifecycleScripts(log$: {
+    lifecycle: Rx.Observable<LifecycleLog>;
+}, opts: {
+    appendOnly?: boolean;
+    aggregateOutput?: boolean;
+    hideLifecyclePrefix?: boolean;
+    cwd: string;
+    width: number;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportLifecycleScripts.js

@@ -0,0 +1,193 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import cliTruncate from 'cli-truncate';
+import prettyTime from 'pretty-ms';
+import * as Rx from 'rxjs';
+import { buffer, filter, groupBy, map, mergeAll, mergeMap } from 'rxjs/operators';
+import { EOL } from '../constants.js';
+import { hlValue } from './outputConstants.js';
+import { formatPrefix, formatPrefixNoTrim } from './utils/formatPrefix.js';
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+const TMP_DIR_IN_STORE = `tmp${path.sep}_tmp_`; // git-hosted dependencies are built in these temporary directories
+// When streaming processes are spawned, use this color for prefix
+const colorWheel = ['cyan', 'magenta', 'blue', 'yellow', 'green', 'red'];
+const NUM_COLORS = colorWheel.length;
+// Ever-increasing index ensures colors are always sequential
+let currentColor = 0;
+export function reportLifecycleScripts(log$, opts) {
+    // When the reporter is not append-only, the length of output is limited
+    // in order to reduce flickering
+    if (opts.appendOnly) {
+        let lifecycle$ = log$.lifecycle;
+        if (opts.aggregateOutput) {
+            lifecycle$ = lifecycle$.pipe(aggregateOutput);
+        }
+        const streamLifecycleOutput = createStreamLifecycleOutput(opts.cwd, !!opts.hideLifecyclePrefix);
+        return lifecycle$.pipe(map((log) => Rx.of({
+            msg: streamLifecycleOutput(log),
+        })));
+    }
+    const lifecycleMessages = {};
+    const lifecycleStreamByDepPath = {};
+    const lifecyclePushStream = new Rx.Subject();
+    // TODO: handle promise of .forEach?!
+    log$.lifecycle
+        .forEach((log) => {
+        const key = `${log.stage}:${log.depPath}`;
+        lifecycleMessages[key] = lifecycleMessages[key] || {
+            collapsed: log.wd.includes(NODE_MODULES) || log.wd.includes(TMP_DIR_IN_STORE),
+            output: [],
+            startTime: process.hrtime(),
+            status: formatIndentedStatus(chalk.magentaBright('Running...')),
+        };
+        const exit = typeof log['exitCode'] === 'number';
+        let msg;
+        if (lifecycleMessages[key].collapsed) {
+            msg = renderCollapsedScriptOutput(log, lifecycleMessages[key], { cwd: opts.cwd, exit, maxWidth: opts.width });
+        }
+        else {
+            msg = renderScriptOutput(log, lifecycleMessages[key], { cwd: opts.cwd, exit, maxWidth: opts.width });
+        }
+        if (exit) {
+            delete lifecycleMessages[key];
+        }
+        if (!lifecycleStreamByDepPath[key]) {
+            lifecycleStreamByDepPath[key] = new Rx.Subject();
+            lifecyclePushStream.next(Rx.from(lifecycleStreamByDepPath[key]));
+        }
+        lifecycleStreamByDepPath[key].next({ msg });
+        if (exit) {
+            lifecycleStreamByDepPath[key].complete();
+        }
+    });
+    return Rx.from(lifecyclePushStream);
+}
+function toNano(time) {
+    return (time[0] + (time[1] / 1e9)) * 1e3;
+}
+function renderCollapsedScriptOutput(log, messageCache, opts) {
+    if (!messageCache.label) {
+        messageCache.label = highlightLastFolder(formatPrefixNoTrim(opts.cwd, log.wd));
+        if (log.wd.includes(TMP_DIR_IN_STORE)) {
+            messageCache.label += ` [${log.depPath}]`;
+        }
+        messageCache.label += `: Running ${log.stage} script`;
+    }
+    if (!opts.exit) {
+        updateMessageCache(log, messageCache, opts);
+        return `${messageCache.label}...`;
+    }
+    const time = prettyTime(toNano(process.hrtime(messageCache.startTime)));
+    if (log.exitCode === 0) {
+        return `${messageCache.label}, done in ${time}`;
+    }
+    if (log.optional === true) {
+        return `${messageCache.label}, failed in ${time} (skipped as optional)`;
+    }
+    return `${messageCache.label}, failed in ${time}${EOL}${renderScriptOutput(log, messageCache, opts)}`;
+}
+function renderScriptOutput(log, messageCache, opts) {
+    updateMessageCache(log, messageCache, opts);
+    if (opts.exit && log['exitCode'] !== 0) {
+        return [
+            messageCache.script,
+            ...messageCache.output,
+            messageCache.status,
+        ].join(EOL);
+    }
+    if (messageCache.output.length > 10) {
+        return [
+            messageCache.script,
+            `[${messageCache.output.length - 10} lines collapsed]`,
+            ...messageCache.output.slice(messageCache.output.length - 10),
+            messageCache.status,
+        ].join(EOL);
+    }
+    return [
+        messageCache.script,
+        ...messageCache.output,
+        messageCache.status,
+    ].join(EOL);
+}
+function updateMessageCache(log, messageCache, opts) {
+    if (log.script) {
+        const prefix = `${formatPrefix(opts.cwd, log.wd)} ${hlValue(log.stage)}`;
+        const maxLineWidth = opts.maxWidth - prefix.length - 2 + ANSI_ESCAPES_LENGTH_OF_PREFIX;
+        messageCache.script = `${prefix}$ ${cutLine(log.script, maxLineWidth)}`;
+    }
+    else if (opts.exit) {
+        const time = prettyTime(toNano(process.hrtime(messageCache.startTime)));
+        if (log.exitCode === 0) {
+            messageCache.status = formatIndentedStatus(chalk.magentaBright(`Done in ${time}`));
+        }
+        else {
+            messageCache.status = formatIndentedStatus(chalk.red(`Failed in ${time} at ${log.wd}`));
+        }
+    }
+    else {
+        messageCache.output.push(formatIndentedOutput(opts.maxWidth, log));
+    }
+}
+function formatIndentedStatus(status) {
+    return `${chalk.magentaBright('└─')} ${status}`;
+}
+function highlightLastFolder(p) {
+    const lastSlash = p.lastIndexOf('/') + 1;
+    return `${chalk.gray(p.slice(0, lastSlash))}${p.slice(lastSlash)}`;
+}
+const ANSI_ESCAPES_LENGTH_OF_PREFIX = hlValue(' ').length - 1;
+function createStreamLifecycleOutput(cwd, hideLifecyclePrefix) {
+    currentColor = 0;
+    const colorByPrefix = new Map();
+    return streamLifecycleOutput.bind(null, colorByPrefix, cwd, hideLifecyclePrefix);
+}
+function streamLifecycleOutput(colorByPkg, cwd, hideLifecyclePrefix, logObj) {
+    const prefix = formatLifecycleScriptPrefix(colorByPkg, cwd, logObj.wd, logObj.stage);
+    if (typeof logObj.exitCode === 'number') {
+        if (logObj.exitCode === 0) {
+            return `${prefix}: Done`;
+        }
+        else {
+            return `${prefix}: Failed`;
+        }
+    }
+    if (logObj['script']) {
+        return `${prefix}$ ${logObj['script']}`;
+    }
+    const line = formatLine(Infinity, logObj);
+    return hideLifecyclePrefix ? line : `${prefix}: ${line}`;
+}
+function formatIndentedOutput(maxWidth, logObj) {
+    return `${chalk.magentaBright('│')} ${formatLine(maxWidth - 2, logObj)}`;
+}
+function formatLifecycleScriptPrefix(colorByPkg, cwd, wd, stage) {
+    if (!colorByPkg.has(wd)) {
+        const colorName = colorWheel[currentColor % NUM_COLORS];
+        colorByPkg.set(wd, chalk[colorName]);
+        currentColor += 1;
+    }
+    const color = colorByPkg.get(wd);
+    return `${color(formatPrefix(cwd, wd))} ${hlValue(stage)}`;
+}
+function formatLine(maxWidth, logObj) {
+    const line = cutLine(logObj.line, maxWidth);
+    // TODO: strip only the non-color/style ansi escape codes
+    if (logObj.stdio === 'stderr') {
+        return chalk.gray(line);
+    }
+    return line;
+}
+function cutLine(line, maxLength) {
+    if (!line)
+        return '';
+    return cliTruncate(line, maxLength);
+}
+function aggregateOutput(source) {
+    return source.pipe(
+    // The '\0' is a null character which delimits these strings. This works since JS doesn't use
+    // null-terminated strings.
+    groupBy((data) => `${data.depPath}\0${data.stage}`), mergeMap(group => {
+        return group.pipe(buffer(group.pipe(filter(msg => 'exitCode' in msg))));
+    }), map(ar => Rx.from(ar)), mergeAll());
+}
+//# sourceMappingURL=reportLifecycleScripts.js.map

package/lib/reporterForClient/reportMisc.d.ts

@@ -0,0 +1,17 @@
+import type { Config } from '@pnpm/config.reader';
+import type { Log, RegistryLog } from '@pnpm/core-loggers';
+import type { LogLevel } from '@pnpm/logger';
+import * as Rx from 'rxjs';
+export declare const LOG_LEVEL_NUMBER: Record<LogLevel, number>;
+export declare function reportMisc(log$: {
+    registry: Rx.Observable<RegistryLog>;
+    other: Rx.Observable<Log>;
+}, opts: {
+    appendOnly: boolean;
+    cwd: string;
+    logLevel?: LogLevel;
+    config?: Config;
+    zoomOutCurrent: boolean;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportMisc.js

@@ -0,0 +1,69 @@
+import os from 'node:os';
+import * as Rx from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { reportError } from '../reportError.js';
+import { formatWarn } from './utils/formatWarn.js';
+import { autozoom } from './utils/zooming.js';
+// eslint-disable:object-literal-sort-keys
+export const LOG_LEVEL_NUMBER = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+};
+// eslint-enable:object-literal-sort-keys
+const MAX_SHOWN_WARNINGS = 5;
+export function reportMisc(log$, opts) {
+    const maxLogLevel = LOG_LEVEL_NUMBER[opts.logLevel ?? 'info'] ?? LOG_LEVEL_NUMBER['info'];
+    const reportWarning = makeWarningReporter(opts);
+    return Rx.merge(log$.registry, log$.other).pipe(filter((obj) => LOG_LEVEL_NUMBER[obj.level] <= maxLogLevel &&
+        (obj.level !== 'info' || !obj['prefix'] || obj['prefix'] === opts.cwd)), map((obj) => {
+        switch (obj.level) {
+            case 'warn': {
+                return reportWarning(obj);
+            }
+            case 'error': {
+                const errorOutput = reportError(obj, opts.config);
+                if (!errorOutput)
+                    return Rx.NEVER;
+                if (obj['prefix'] && obj['prefix'] !== opts.cwd) {
+                    return Rx.of({
+                        msg: `${obj['prefix']}:` + os.EOL + errorOutput,
+                    });
+                }
+                return Rx.of({ msg: errorOutput });
+            }
+            default:
+                return Rx.of({ msg: obj.message });
+        }
+    }));
+}
+// Sometimes, when installing new dependencies that rely on many peer dependencies,
+// or when running installation on a huge monorepo, there will be hundreds or thousands of warnings.
+// Printing many messages to the terminal is expensive and reduces speed,
+// so pnpm will only print a few warnings and report the total number of the unprinted warnings.
+function makeWarningReporter(opts) {
+    let warningsCounter = 0;
+    let collapsedWarnings;
+    return (obj) => {
+        warningsCounter++;
+        if (opts.appendOnly || warningsCounter <= MAX_SHOWN_WARNINGS) {
+            return Rx.of({ msg: autozoom(opts.cwd, obj.prefix, formatWarn(obj.message), opts) });
+        }
+        const warningMsg = formatWarn(`${warningsCounter - MAX_SHOWN_WARNINGS} other warnings`);
+        if (!collapsedWarnings) {
+            collapsedWarnings = new Rx.Subject();
+            // For some reason, without using setTimeout, the warning summary is printed above the rest of the warnings
+            // Even though the summary event happens last. Probably a bug in "most".
+            setTimeout(() => {
+                collapsedWarnings.next({ msg: warningMsg });
+            }, 0);
+            return Rx.from(collapsedWarnings);
+        }
+        setTimeout(() => {
+            collapsedWarnings.next({ msg: warningMsg });
+        }, 0);
+        return Rx.NEVER;
+    };
+}
+//# sourceMappingURL=reportMisc.js.map