@pnpm/cli.default-reporter 1100.3.11 → 1100.3.13

package/lib/reporterForClient/reportLifecycleScripts.js

@@ -0,0 +1,197 @@
+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 '';
+    // Streamed lifecycle output is printed in full (maxLength is Infinity).
+    // cli-truncate rejects a non-finite width, so skip truncation in that case.
+    if (!Number.isFinite(maxLength))
+        return line;
+    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/reportLockfileVerification.d.ts

@@ -0,0 +1,15 @@
+import type { LockfileVerificationLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export interface ReportLockfileVerificationOptions {
+    cwd: string;
+    /**
+     * The workspace root, when one exists. Used as the "expected"
+     * location for the lockfile — when the lockfile lives there, the
+     * path is implied and we don't repeat it in the rendered message.
+     * Falls back to `cwd` for single-project installs.
+     */
+    workspaceDir?: string;
+}
+export declare function reportLockfileVerification(lockfileVerification$: Rx.Observable<LockfileVerificationLog>, opts: ReportLockfileVerificationOptions): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportLockfileVerification.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import normalize from 'normalize-path';
+import prettyMs from 'pretty-ms';
+import * as Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+export function reportLockfileVerification(lockfileVerification$, opts) {
+    const expectedDir = opts.workspaceDir ?? opts.cwd;
+    // A single inner observable so the `done` message overwrites the
+    // transient `started` message when the reporter redraws in place. In
+    // appendOnly mode both lines are printed.
+    return Rx.of(lockfileVerification$.pipe(map((log) => {
+        const path_ = formatLockfilePath(log.lockfilePath, opts.cwd, expectedDir);
+        if (log.status === 'cached') {
+            return {
+                msg: `${chalk.green('✓')} Lockfile${path_} passes supply-chain policies (${formatCachedVerdict(log.verifiedAt)})`,
+            };
+        }
+        const entries = `${log.entries} ${log.entries === 1 ? 'entry' : 'entries'}`;
+        switch (log.status) {
+            case 'started':
+                return {
+                    msg: `${chalk.cyan('?')} Verifying lockfile${path_} against supply-chain policies (${entries})...`,
+                };
+            case 'done':
+                return {
+                    msg: `${chalk.green('✓')} Lockfile${path_} passes supply-chain policies (${entries} in ${prettyMs(log.elapsedMs)})`,
+                };
+            case 'failed':
+                // Brief one-liner so the transient `started` frame doesn't
+                // stay on screen above the detailed PnpmError block that the
+                // error reporter prints next.
+                return {
+                    msg: `${chalk.red('✗')} Lockfile${path_} failed supply-chain policy check (${entries} in ${prettyMs(log.elapsedMs)})`,
+                };
+        }
+    })));
+}
+// Relative "verified 2h ago" when the cached record carries a parseable
+// timestamp; the timeless "previously verified" otherwise. The elapsed
+// time is clamped at zero so a clock that moved backwards between the
+// verification run and this install doesn't render a negative age.
+function formatCachedVerdict(verifiedAt) {
+    if (verifiedAt == null)
+        return 'previously verified';
+    const elapsedMs = Date.now() - Date.parse(verifiedAt);
+    if (Number.isNaN(elapsedMs))
+        return 'previously verified';
+    return `verified ${prettyMs(Math.max(elapsedMs, 0), { compact: true })} ago`;
+}
+// Returns a leading-space-prefixed `at <path>` suffix only when the
+// lockfile sits outside the obvious project/workspace root — otherwise
+// the path is implied and printing it would just add noise to every
+// install. Empty string when the path is omitted or matches the
+// expected location.
+//
+// Uses `path.relative` rather than a strict `===` between
+// `path.dirname(lockfilePath)` and `expectedDir`: relative path
+// computation normalizes slash direction and trailing separators, so
+// a workspaceDir like `C:/repo/` correctly matches a lockfilePath at
+// `C:\repo\pnpm-lock.yaml` on Windows. The lockfile is considered
+// "inside the expected dir" when the relative path is a bare file
+// name (no separator) that doesn't escape upward.
+function formatLockfilePath(lockfilePath, cwd, expectedDir) {
+    if (lockfilePath == null)
+        return '';
+    const fromExpected = path.relative(expectedDir, lockfilePath);
+    const isDirectChild = !fromExpected.includes(path.sep) && !fromExpected.startsWith('..');
+    if (isDirectChild)
+        return '';
+    return ` at ${normalize(path.relative(cwd, lockfilePath))}`;
+}
+//# sourceMappingURL=reportLockfileVerification.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

package/lib/reporterForClient/reportPeerDependencyIssues.d.ts

@@ -0,0 +1,7 @@
+import type { PeerDependencyIssuesLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportPeerDependencyIssues(log$: {
+    peerDependencyIssues: Rx.Observable<PeerDependencyIssuesLog>;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportPeerDependencyIssues.js

@@ -0,0 +1,11 @@
+import * as Rx from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import { formatWarn } from './utils/formatWarn.js';
+export function reportPeerDependencyIssues(log$) {
+    return log$.peerDependencyIssues.pipe(take(1), map(() => {
+        return Rx.of({
+            msg: formatWarn('Issues with peer dependencies found. Run "pnpm peers check" to list them.'),
+        });
+    }));
+}
+//# sourceMappingURL=reportPeerDependencyIssues.js.map

package/lib/reporterForClient/reportProgress.d.ts

@@ -0,0 +1,16 @@
+import type { ProgressLog, StageLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export interface StatusMessage {
+    msg: string;
+    fixed: boolean;
+    done?: boolean;
+}
+export declare function reportProgress(log$: {
+    progress: Rx.Observable<ProgressLog>;
+    stage: Rx.Observable<StageLog>;
+}, opts: {
+    cwd: string;
+    throttle?: Rx.OperatorFunction<any, any>;
+    hideAddedPkgsProgress?: boolean;
+    hideProgressPrefix?: boolean;
+}): Rx.Observable<Rx.Observable<StatusMessage>>;

package/lib/reporterForClient/reportProgress.js

@@ -0,0 +1,123 @@
+import * as Rx from 'rxjs';
+import { filter, map, mapTo, startWith, take, takeWhile } from 'rxjs/operators';
+import { hlValue } from './outputConstants.js';
+import { zoomOut } from './utils/zooming.js';
+export function reportProgress(log$, opts) {
+    const progressOutput = throttledProgressOutput.bind(null, opts);
+    return getModulesInstallProgress$(log$.stage, log$.progress).pipe(map(opts.hideProgressPrefix
+        ? ({ importingDone$, progress$ }) => progressOutput(importingDone$, progress$)
+        : ({ importingDone$, progress$, requirer }) => {
+            const output$ = progressOutput(importingDone$, progress$);
+            if (requirer === opts.cwd) {
+                return output$;
+            }
+            return output$.pipe(map((msg) => {
+                msg['msg'] = zoomOut(opts.cwd, requirer, msg['msg']);
+                return msg;
+            }));
+        }));
+}
+function throttledProgressOutput(opts, importingDone$, progress$) {
+    if (opts.throttle != null) {
+        progress$ = progress$.pipe(opts.throttle);
+    }
+    const combinedProgress = Rx.combineLatest(progress$, importingDone$)
+        // Avoid logs after all resolved packages were downloaded.
+        // Fixing issue: https://github.com/pnpm/pnpm/issues/1028#issuecomment-364782901
+        .pipe(takeWhile(([, importingDone]) => !importingDone, true));
+    return combinedProgress.pipe(map(opts.hideAddedPkgsProgress ? createStatusMessageWithoutAdded : createStatusMessage));
+}
+function getModulesInstallProgress$(stage$, progress$) {
+    const modulesInstallProgressPushStream = new Rx.Subject();
+    const progressStatsPushStreamByRequirer = getProgressStatsPushStreamByRequirer(progress$);
+    const stagePushStreamByRequirer = {};
+    stage$
+        .forEach((log) => {
+        if (!stagePushStreamByRequirer[log.prefix]) {
+            stagePushStreamByRequirer[log.prefix] = new Rx.Subject();
+            if (!progressStatsPushStreamByRequirer[log.prefix]) {
+                progressStatsPushStreamByRequirer[log.prefix] = new Rx.Subject();
+            }
+            modulesInstallProgressPushStream.next({
+                importingDone$: stage$ToImportingDone$(Rx.from(stagePushStreamByRequirer[log.prefix])),
+                progress$: Rx.from(progressStatsPushStreamByRequirer[log.prefix]),
+                requirer: log.prefix,
+            });
+        }
+        stagePushStreamByRequirer[log.prefix].next(log);
+        if (log.stage === 'importing_done') {
+            progressStatsPushStreamByRequirer[log.prefix].complete();
+            stagePushStreamByRequirer[log.prefix].complete();
+        }
+    })
+        .catch(() => { });
+    return Rx.from(modulesInstallProgressPushStream);
+}
+function stage$ToImportingDone$(stage$) {
+    return stage$
+        .pipe(filter((log) => log.stage === 'importing_done'), mapTo(true), take(1), startWith(false));
+}
+function getProgressStatsPushStreamByRequirer(progress$) {
+    const progressStatsPushStreamByRequirer = {};
+    const previousProgressStatsByRequirer = {};
+    progress$
+        .forEach((log) => {
+        if (!previousProgressStatsByRequirer[log.requester]) {
+            previousProgressStatsByRequirer[log.requester] = {
+                fetched: 0,
+                imported: 0,
+                resolved: 0,
+                reused: 0,
+            };
+        }
+        switch (log.status) {
+            case 'resolved':
+                previousProgressStatsByRequirer[log.requester].resolved++;
+                break;
+            case 'fetched':
+                previousProgressStatsByRequirer[log.requester].fetched++;
+                break;
+            case 'found_in_store':
+                previousProgressStatsByRequirer[log.requester].reused++;
+                break;
+            case 'imported':
+                previousProgressStatsByRequirer[log.requester].imported++;
+                break;
+        }
+        if (!progressStatsPushStreamByRequirer[log.requester]) {
+            progressStatsPushStreamByRequirer[log.requester] = new Rx.Subject();
+        }
+        progressStatsPushStreamByRequirer[log.requester].next(previousProgressStatsByRequirer[log.requester]);
+    })
+        .catch(() => { });
+    return progressStatsPushStreamByRequirer;
+}
+function createStatusMessage([progress, importingDone]) {
+    const msg = `Progress: resolved ${hlValue(progress.resolved.toString())}, reused ${hlValue(progress.reused.toString())}, downloaded ${hlValue(progress.fetched.toString())}, added ${hlValue(progress.imported.toString())}`;
+    if (importingDone) {
+        return {
+            done: true,
+            fixed: false,
+            msg: `${msg}, done`,
+        };
+    }
+    return {
+        fixed: true,
+        msg,
+    };
+}
+function createStatusMessageWithoutAdded([progress, importingDone]) {
+    const msg = `Progress: resolved ${hlValue(progress.resolved.toString())}, reused ${hlValue(progress.reused.toString())}, downloaded ${hlValue(progress.fetched.toString())}`;
+    if (importingDone) {
+        return {
+            done: true,
+            fixed: false,
+            msg: `${msg}, done`,
+        };
+    }
+    return {
+        fixed: true,
+        msg,
+    };
+}
+//# sourceMappingURL=reportProgress.js.map

package/lib/reporterForClient/reportRequestRetry.d.ts

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

package/lib/reporterForClient/reportRequestRetry.js

@@ -0,0 +1,18 @@
+import prettyMilliseconds from 'pretty-ms';
+import * as Rx from 'rxjs';
+import { map } from 'rxjs/operators';
+import { formatWarn } from './utils/formatWarn.js';
+export function reportRequestRetry(requestRetry$) {
+    return requestRetry$.pipe(map((log) => {
+        const retriesLeft = log.maxRetries - log.attempt + 1;
+        // Extract error code from various possible locations
+        // HTTP status codes are numeric, system error codes are strings
+        const errorCode = log.error.status ?? log.error.statusCode ?? log.error.code ?? log.error.errno ??
+            log.error.cause?.code ?? log.error.cause?.errno ?? 'unknown';
+        const msg = `${log.method} ${log.url} error (${errorCode}). \
+Will retry in ${prettyMilliseconds(log.timeout, { verbose: true })}. \
+${retriesLeft} retries left.`;
+        return Rx.of({ msg: formatWarn(msg) });
+    }));
+}
+//# sourceMappingURL=reportRequestRetry.js.map

package/lib/reporterForClient/reportScope.d.ts

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

package/lib/reporterForClient/reportScope.js

@@ -0,0 +1,41 @@
+import * as Rx from 'rxjs';
+import { map, take } from 'rxjs/operators';
+const COMMANDS_THAT_REPORT_SCOPE = new Set([
+    'install',
+    'link',
+    'prune',
+    'rebuild',
+    'remove',
+    'unlink',
+    'update',
+    'run',
+    'test',
+]);
+export function reportScope(scope$, opts) {
+    if (!COMMANDS_THAT_REPORT_SCOPE.has(opts.cmd)) {
+        return Rx.NEVER;
+    }
+    return scope$.pipe(take(1), map((log) => {
+        if (log.selected === 1) {
+            return Rx.NEVER;
+        }
+        let msg = 'Scope: ';
+        if (log.selected === log.total) {
+            msg += `all ${log.total}`;
+        }
+        else {
+            msg += `${log.selected}`;
+            if (log.total) {
+                msg += ` of ${log.total}`;
+            }
+        }
+        if (log.workspacePrefix) {
+            msg += ' workspace projects';
+        }
+        else {
+            msg += ' projects';
+        }
+        return Rx.of({ msg });
+    }));
+}
+//# sourceMappingURL=reportScope.js.map

package/lib/reporterForClient/reportSkippedOptionalDependencies.d.ts

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

package/lib/reporterForClient/reportSkippedOptionalDependencies.js

@@ -0,0 +1,8 @@
+import * as Rx from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+export function reportSkippedOptionalDependencies(skippedOptionalDependency$, opts) {
+    return skippedOptionalDependency$.pipe(filter((log) => Boolean(log['prefix'] === opts.cwd && log.parents && log.parents.length === 0)), map((log) => Rx.of({
+        msg: `info: ${log.package.id || log.package.name && (`${log.package.name}@${log.package.version}`) || log.package.bareSpecifier} is an optional dependency and failed compatibility check. Excluding it from installation.`,
+    })));
+}
+//# sourceMappingURL=reportSkippedOptionalDependencies.js.map

package/lib/reporterForClient/reportStats.d.ts

@@ -0,0 +1,13 @@
+import type { StatsLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportStats(log$: {
+    stats: Rx.Observable<StatsLog>;
+}, opts: {
+    cmd: string;
+    cwd: string;
+    isRecursive: boolean;
+    width: number;
+    hideProgressPrefix?: boolean;
+}): Array<Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>>;