@pnpm/cli.default-reporter 1100.3.11 → 1100.3.13

package/lib/reporterForClient/index.d.ts

@@ -0,0 +1,53 @@
+import type { Config, ConfigContext } 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>;
+    lockfileVerification: Rx.Observable<logs.LockfileVerificationLog>;
+    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 & ConfigContext;
+    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,98 @@
+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 { reportLockfileVerification } from './reportLockfileVerification.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), reportLockfileVerification(log$.lockfileVerification, {
+            cwd,
+            workspaceDir: opts.pnpmConfig?.workspaceDir,
+        }), 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>;

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, ConfigContext } 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 & ConfigContext;
+    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;
+}>>;