@pnpm/cli.default-reporter 1002.0.11

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,16 @@
+import { renderPeerIssues } from '@pnpm/installing.render-peer-issues';
+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((log) => {
+        const renderedPeerIssues = renderPeerIssues(log.issuesByProjects);
+        if (!renderedPeerIssues) {
+            return Rx.NEVER;
+        }
+        return Rx.of({
+            msg: `${formatWarn('Issues with peer dependencies found')}\n${renderedPeerIssues}`,
+        });
+    }));
+}
+//# 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,15 @@
+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;
+        const errorCode = log.error.httpStatusCode ?? log.error.status ?? log.error.errno ?? log.error.code;
+        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;
+}>>>;

package/lib/reporterForClient/reportStats.js

@@ -0,0 +1,143 @@
+import chalk from 'chalk';
+import { repeat } from 'ramda';
+import * as Rx from 'rxjs';
+import { filter, map, reduce, take } from 'rxjs/operators';
+import stringLength from 'string-length';
+import { EOL } from '../constants.js';
+import { ADDED_CHAR, REMOVED_CHAR, } from './outputConstants.js';
+import { zoomOut } from './utils/zooming.js';
+export function reportStats(log$, opts) {
+    if (opts.hideProgressPrefix) {
+        return [statsForCurrentPackage(log$.stats, {
+                cmd: opts.cmd,
+                width: opts.width,
+            })];
+    }
+    const stats$ = opts.isRecursive
+        ? log$.stats
+        : log$.stats.pipe(filter((log) => log.prefix !== opts.cwd));
+    const outputs = [
+        statsForNotCurrentPackage(stats$, {
+            cmd: opts.cmd,
+            currentPrefix: opts.cwd,
+            width: opts.width,
+        }),
+    ];
+    if (!opts.isRecursive) {
+        outputs.push(statsForCurrentPackage(log$.stats.pipe(filter((log) => log.prefix === opts.cwd)), {
+            cmd: opts.cmd,
+            width: opts.width,
+        }));
+    }
+    return outputs;
+}
+function statsForCurrentPackage(stats$, opts) {
+    return stats$.pipe(take((opts.cmd === 'install' || opts.cmd === 'install-test' || opts.cmd === 'add' || opts.cmd === 'update' || opts.cmd === 'dlx') ? 2 : 1), reduce((acc, log) => {
+        if (typeof log['added'] === 'number') {
+            acc['added'] = log['added'];
+        }
+        else if (typeof log['removed'] === 'number') {
+            acc['removed'] = log['removed'];
+        }
+        return acc;
+    }, {}), map((stats) => {
+        if (!stats['removed'] && !stats['added']) {
+            if (opts.cmd === 'link') {
+                return Rx.NEVER;
+            }
+            return Rx.of({ msg: 'Already up to date' });
+        }
+        let msg = 'Packages:';
+        if (stats['added']) {
+            msg += ' ' + chalk.green(`+${stats['added'].toString()}`);
+        }
+        if (stats['removed']) {
+            msg += ' ' + chalk.red(`-${stats['removed'].toString()}`);
+        }
+        msg += EOL + printPlusesAndMinuses(opts.width, (stats['added'] ?? 0), (stats['removed'] ?? 0));
+        return Rx.of({ msg });
+    }));
+}
+function statsForNotCurrentPackage(stats$, opts) {
+    const stats = {};
+    const cookedStats$ = (opts.cmd !== 'remove'
+        ? stats$.pipe(map((log) => {
+            // As of pnpm v2.9.0, during `pnpm recursive link`, logging of removed stats happens twice
+            //  1. during linking
+            //  2. during installing
+            // Hence, the stats are added before reported
+            const { prefix } = log;
+            if (!stats[prefix]) {
+                stats[prefix] = log;
+                return { seed: stats, value: null };
+            }
+            else if (typeof stats[prefix].added === 'number' && typeof log['added'] === 'number') {
+                stats[prefix].added += log['added'];
+                return { seed: stats, value: null };
+            }
+            else if (typeof stats[prefix].removed === 'number' && typeof log['removed'] === 'number') {
+                stats[prefix].removed += log['removed'];
+                return { seed: stats, value: null };
+            }
+            else {
+                const value = { ...stats[prefix], ...log };
+                delete stats[prefix];
+                return value;
+            }
+        }, {}))
+        : stats$);
+    return cookedStats$.pipe(filter((stats) => stats !== null && Boolean(stats['removed'] || stats['added'])), map((stats) => {
+        const parts = [];
+        if (stats['added']) {
+            parts.push(padStep(chalk.green(`+${stats['added'].toString()}`), 4));
+        }
+        if (stats['removed']) {
+            parts.push(padStep(chalk.red(`-${stats['removed'].toString()}`), 4));
+        }
+        let msg = zoomOut(opts.currentPrefix, stats.prefix, parts.join(' '));
+        const rest = Math.max(0, opts.width - 1 - stringLength(msg));
+        msg += ' ' + printPlusesAndMinuses(rest, roundStats(stats['added'] || 0), roundStats(stats['removed'] || 0));
+        return Rx.of({ msg });
+    }));
+}
+function padStep(s, step) {
+    const sLength = stringLength(s);
+    const placeholderLength = Math.ceil(sLength / step) * step;
+    if (sLength < placeholderLength) {
+        return repeat(' ', placeholderLength - sLength).join('') + s;
+    }
+    return s;
+}
+function roundStats(stat) {
+    if (stat === 0)
+        return 0;
+    return Math.max(1, Math.round(stat / 10));
+}
+function printPlusesAndMinuses(maxWidth, added, removed) {
+    if (maxWidth === 0)
+        return '';
+    const changes = added + removed;
+    let addedChars;
+    let removedChars;
+    if (changes > maxWidth) {
+        if (!added) {
+            addedChars = 0;
+            removedChars = maxWidth;
+        }
+        else if (!removed) {
+            addedChars = maxWidth;
+            removedChars = 0;
+        }
+        else {
+            const p = maxWidth / changes;
+            addedChars = Math.min(Math.max(Math.floor(added * p), 1), maxWidth - 1);
+            removedChars = maxWidth - addedChars;
+        }
+    }
+    else {
+        addedChars = added;
+        removedChars = removed;
+    }
+    return `${repeat(ADDED_CHAR, addedChars).join('')}${repeat(REMOVED_CHAR, removedChars).join('')}`;
+}
+//# sourceMappingURL=reportStats.js.map

package/lib/reporterForClient/reportSummary.d.ts

@@ -0,0 +1,19 @@
+import type { Config } from '@pnpm/config.reader';
+import type { DeprecationLog, PackageManifestLog, RootLog, SummaryLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+import { type PackageDiff } from './pkgsDiff.js';
+export declare function reportSummary(log$: {
+    deprecation: Rx.Observable<DeprecationLog>;
+    summary: Rx.Observable<SummaryLog>;
+    root: Rx.Observable<RootLog>;
+    packageManifest: Rx.Observable<PackageManifestLog>;
+}, opts: {
+    cmd: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    filterPkgsDiff?: FilterPkgsDiff;
+    pnpmConfig?: Config;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;
+export type FilterPkgsDiff = (pkgsDiff: PackageDiff) => boolean;

package/lib/reporterForClient/reportSummary.js

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import * as Rx from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import semver from 'semver';
+import { EOL } from '../constants.js';
+import { ADDED_CHAR, REMOVED_CHAR, } from './outputConstants.js';
+import { getPkgsDiff, propertyByDependencyType, } from './pkgsDiff.js';
+const CONFIG_BY_DEP_TYPE = {
+    prod: 'production',
+    dev: 'dev',
+    optional: 'optional',
+};
+export function reportSummary(log$, opts) {
+    const pkgsDiff$ = getPkgsDiff(log$, { prefix: opts.pnpmConfig?.global ? undefined : opts.cwd });
+    const summaryLog$ = log$.summary.pipe(take(1));
+    const _printDiffs = printDiffs.bind(null, { cmd: opts.cmd, prefix: opts.cwd, pnpmConfig: opts.pnpmConfig });
+    return Rx.combineLatest(pkgsDiff$, summaryLog$)
+        .pipe(take(1), map(([pkgsDiff]) => {
+        let msg = '';
+        for (const depType of ['prod', 'optional', 'peer', 'dev', 'nodeModulesOnly']) {
+            let diffs = Object.values(pkgsDiff[depType]);
+            if (opts.filterPkgsDiff) {
+                // This filtering is only used by Bit CLI currently.
+                // Related PR: https://github.com/teambit/bit/pull/7176
+                diffs = diffs.filter((pkgDiff) => opts.filterPkgsDiff(pkgDiff));
+            }
+            if (diffs.length > 0) {
+                msg += EOL;
+                msg += chalk.cyanBright(opts.pnpmConfig?.global ? 'global:' : `${propertyByDependencyType[depType]}:`);
+                msg += EOL;
+                msg += _printDiffs(diffs, depType);
+                msg += EOL;
+            }
+            else if (CONFIG_BY_DEP_TYPE[depType] && opts.pnpmConfig?.[CONFIG_BY_DEP_TYPE[depType]] === false) {
+                msg += EOL;
+                msg += `${chalk.cyanBright(`${propertyByDependencyType[depType]}:`)} skipped`;
+                msg += EOL;
+            }
+        }
+        return Rx.of({ msg });
+    }));
+}
+function printDiffs(opts, pkgsDiff, depType) {
+    // Sorts by alphabet then by removed/added
+    // + ava 0.10.0
+    // - chalk 1.0.0
+    // + chalk 2.0.0
+    pkgsDiff.sort((a, b) => (a.name.localeCompare(b.name) * 10 + (Number(!b.added) - Number(!a.added))));
+    const msg = pkgsDiff.map((pkg) => {
+        let result = pkg.added
+            ? ADDED_CHAR
+            : REMOVED_CHAR;
+        if (!pkg.realName || pkg.name === pkg.realName) {
+            result += ` ${pkg.name}`;
+        }
+        else {
+            result += ` ${pkg.name} <- ${pkg.realName}`;
+        }
+        if (pkg.version) {
+            result += ` ${chalk.grey(pkg.version)}`;
+            if (pkg.latest && semver.lt(pkg.version, pkg.latest)) {
+                result += ` ${chalk.grey(`(${pkg.latest} is available)`)}`;
+            }
+        }
+        if (pkg.deprecated) {
+            result += ` ${chalk.red('deprecated')}`;
+        }
+        if (pkg.from) {
+            result += ` ${chalk.grey(`<- ${path.relative(opts.prefix, pkg.from) || pkg.from}`)}`;
+        }
+        if (pkg.added && depType === 'dev' && opts.pnpmConfig?.saveDev === false && opts.cmd === 'add') {
+            result += `${chalk.yellow(' already in devDependencies, was not moved to dependencies.')}`;
+        }
+        return result;
+    }).join(EOL);
+    return msg;
+}
+//# sourceMappingURL=reportSummary.js.map

package/lib/reporterForClient/reportUpdateCheck.d.ts

@@ -0,0 +1,8 @@
+import type { UpdateCheckLog } from '@pnpm/core-loggers';
+import * as Rx from 'rxjs';
+export declare function reportUpdateCheck(log$: Rx.Observable<UpdateCheckLog>, opts: {
+    env: NodeJS.ProcessEnv;
+    process: NodeJS.Process;
+}): Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>;

package/lib/reporterForClient/reportUpdateCheck.js

@@ -0,0 +1,42 @@
+import { detectIfCurrentPkgIsExecutable, isExecutedByCorepack } from '@pnpm/cli.meta';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import * as Rx from 'rxjs';
+import { filter, map, take } from 'rxjs/operators';
+import semver from 'semver';
+export function reportUpdateCheck(log$, opts) {
+    return log$.pipe(take(1), filter((log) => semver.gt(log.latestVersion, log.currentVersion)), map((log) => {
+        const updateMessage = renderUpdateMessage({
+            currentPkgIsExecutable: detectIfCurrentPkgIsExecutable(opts.process),
+            latestVersion: log.latestVersion,
+            env: opts.env,
+        });
+        return Rx.of({
+            msg: boxen(`\
+Update available! ${chalk.red(log.currentVersion)} → ${chalk.green(log.latestVersion)}.
+${chalk.magenta('Changelog:')} https://pnpm.io/v/${log.latestVersion}
+${updateMessage}`, {
+                padding: 1,
+                margin: 1,
+                align: 'center',
+                borderColor: 'yellow',
+                borderStyle: 'round',
+            }),
+        });
+    }));
+}
+function renderUpdateMessage(opts) {
+    const updateCommand = renderUpdateCommand(opts);
+    return `To update, run: ${chalk.magenta(updateCommand)}`;
+}
+function renderUpdateCommand(opts) {
+    if (isExecutedByCorepack(opts.env)) {
+        return `corepack use pnpm@${opts.latestVersion}`;
+    }
+    if (opts.env.PNPM_HOME) {
+        return 'pnpm self-update';
+    }
+    const pkgName = opts.currentPkgIsExecutable ? '@pnpm/exe' : 'pnpm';
+    return `pnpm add -g ${pkgName}`;
+}
+//# sourceMappingURL=reportUpdateCheck.js.map

package/lib/reporterForClient/utils/formatPrefix.d.ts

@@ -0,0 +1,2 @@
+export declare function formatPrefix(cwd: string, prefix: string): string;
+export declare function formatPrefixNoTrim(cwd: string, prefix: string): string;

package/lib/reporterForClient/utils/formatPrefix.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import normalize from 'normalize-path';
+import { PREFIX_MAX_LENGTH } from '../outputConstants.js';
+export function formatPrefix(cwd, prefix) {
+    prefix = formatPrefixNoTrim(cwd, prefix);
+    if (prefix.length <= PREFIX_MAX_LENGTH) {
+        return prefix;
+    }
+    const shortPrefix = prefix.slice(-PREFIX_MAX_LENGTH + 3);
+    const separatorLocation = shortPrefix.indexOf('/');
+    if (separatorLocation <= 0) {
+        return `...${shortPrefix}`;
+    }
+    return `...${shortPrefix.slice(separatorLocation)}`;
+}
+export function formatPrefixNoTrim(cwd, prefix) {
+    return normalize(path.relative(cwd, prefix) || '.');
+}
+//# sourceMappingURL=formatPrefix.js.map

package/lib/reporterForClient/utils/formatWarn.d.ts

@@ -0,0 +1 @@
+export declare function formatWarn(message: string): string;

package/lib/reporterForClient/utils/formatWarn.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export function formatWarn(message) {
+    // The \u2009 is the "thin space" unicode character
+    // It is used instead of ' ' because chalk (as of version 2.1.0)
+    // trims whitespace at the beginning
+    return `${chalk.bgYellow.black('\u2009WARN\u2009')} ${message}`;
+}
+//# sourceMappingURL=formatWarn.js.map

package/lib/reporterForClient/utils/zooming.d.ts

@@ -0,0 +1,4 @@
+export declare function autozoom(currentPrefix: string, logPrefix: string | undefined, line: string, opts: {
+    zoomOutCurrent: boolean;
+}): string;
+export declare function zoomOut(currentPrefix: string, logPrefix: string, line: string): string;

package/lib/reporterForClient/utils/zooming.js

@@ -0,0 +1,13 @@
+import { PREFIX_MAX_LENGTH } from '../outputConstants.js';
+import { formatPrefix } from './formatPrefix.js';
+export function autozoom(currentPrefix, logPrefix, line, opts) {
+    if (!logPrefix || !opts.zoomOutCurrent && currentPrefix === logPrefix) {
+        return line;
+    }
+    return zoomOut(currentPrefix, logPrefix, line);
+}
+export function zoomOut(currentPrefix, logPrefix, line) {
+    const prefix = formatPrefix(currentPrefix, logPrefix);
+    return `${prefix.padEnd(PREFIX_MAX_LENGTH)} | ${line}`;
+}
+//# sourceMappingURL=zooming.js.map