@pnpm/cli.default-reporter 1002.0.11

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @pnpm/default-reporter
+
+> The default reporter of pnpm
+
+## Installation
+
+```
+pnpm add @pnpm/default-reporter
+```
+
+## Usage
+
+```ts
+import { streamParser } from '@pnpm/logger'
+import { initDefaultReporter } from '@pnpm/default-reporter'
+
+const stopReporting = initDefaultReporter({
+  context: {
+    argv: [],
+  },
+  streamParser,
+})
+
+try {
+  // calling some pnpm APIs
+} finally {
+  stopReporting()
+}
+```
+
+## Style Guide
+
+1. Never use blue or grey as font color as they are hard to read in many consoles.
+   1. Use dim instead of grey
+   1. Use cyan bright instead of blue
+1. Don't hide the CLI cursor. (It is easier to never hide but it is really needed only when scripts are running.)
+1. Don't use green and yellow to distinct something.
+
+## License
+
+[MIT](LICENSE)

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const EOL = "\n";

package/lib/constants.js

@@ -0,0 +1,4 @@
+// In terminals, always Unix line endings are used
+// even on Windows
+export const EOL = '\n';
+//# sourceMappingURL=constants.js.map

package/lib/index.d.ts

@@ -0,0 +1,54 @@
+import type { Config } from '@pnpm/config.reader';
+import type * as logs from '@pnpm/core-loggers';
+import type { LogLevel, StreamParser } from '@pnpm/logger';
+import * as Rx from 'rxjs';
+import type { FilterPkgsDiff } from './reporterForClient/reportSummary.js';
+import { formatWarn } from './reporterForClient/utils/formatWarn.js';
+export { formatWarn };
+export declare function initDefaultReporter(opts: {
+    useStderr?: boolean;
+    streamParser: StreamParser<logs.Log>;
+    reportingOptions?: {
+        appendOnly?: boolean;
+        logLevel?: LogLevel;
+        streamLifecycleOutput?: boolean;
+        aggregateOutput?: boolean;
+        throttleProgress?: number;
+        outputMaxWidth?: number;
+        hideAddedPkgsProgress?: boolean;
+        hideProgressPrefix?: boolean;
+        hideLifecycleOutput?: boolean;
+        hideLifecyclePrefix?: boolean;
+        approveBuildsInstructionText?: string;
+    };
+    context: {
+        argv: string[];
+        config?: Config;
+        env?: NodeJS.ProcessEnv;
+        process?: NodeJS.Process;
+    };
+    filterPkgsDiff?: FilterPkgsDiff;
+}): () => void;
+export declare function toOutput$(opts: {
+    streamParser: StreamParser<logs.Log>;
+    reportingOptions?: {
+        appendOnly?: boolean;
+        logLevel?: LogLevel;
+        outputMaxWidth?: number;
+        streamLifecycleOutput?: boolean;
+        aggregateOutput?: boolean;
+        throttleProgress?: number;
+        hideAddedPkgsProgress?: boolean;
+        hideProgressPrefix?: boolean;
+        hideLifecycleOutput?: boolean;
+        hideLifecyclePrefix?: boolean;
+        approveBuildsInstructionText?: string;
+    };
+    context: {
+        argv: string[];
+        config?: Config;
+        env?: NodeJS.ProcessEnv;
+        process?: NodeJS.Process;
+    };
+    filterPkgsDiff?: FilterPkgsDiff;
+}): Rx.Observable<string>;

package/lib/index.js

@@ -0,0 +1,230 @@
+import createDiffer from 'ansi-diff';
+import * as Rx from 'rxjs';
+import { filter, map, mergeAll } from 'rxjs/operators';
+import { EOL } from './constants.js';
+import { mergeOutputs } from './mergeOutputs.js';
+import { reporterForClient } from './reporterForClient/index.js';
+import { formatWarn } from './reporterForClient/utils/formatWarn.js';
+export { formatWarn };
+export function initDefaultReporter(opts) {
+    const proc = opts.context.process ?? process;
+    const outputMaxWidth = opts.reportingOptions?.outputMaxWidth ?? (proc.stdout.columns && proc.stdout.columns - 2) ?? 80;
+    const output$ = toOutput$({
+        ...opts,
+        reportingOptions: {
+            ...opts.reportingOptions,
+            outputMaxWidth,
+        },
+    });
+    if (opts.reportingOptions?.appendOnly) {
+        const writeNext = opts.useStderr
+            ? console.error.bind(console)
+            : console.log.bind(console);
+        const subscription = output$
+            .subscribe({
+            complete() { }, // eslint-disable-line:no-empty
+            error: (err) => {
+                console.error(err.message);
+            },
+            next: writeNext,
+        });
+        return () => {
+            subscription.unsubscribe();
+        };
+    }
+    const diff = createDiffer({
+        height: proc.stdout.rows,
+        outputMaxWidth,
+    });
+    const subscription = output$
+        .subscribe({
+        complete() { }, // eslint-disable-line:no-empty
+        error: (err) => {
+            logUpdate(err.message);
+        },
+        next: logUpdate,
+    });
+    const write = opts.useStderr
+        ? proc.stderr.write.bind(proc.stderr)
+        : proc.stdout.write.bind(proc.stdout);
+    function logUpdate(view) {
+        // A new line should always be appended in case a prompt needs to appear.
+        // Without a new line the prompt will be joined with the previous output.
+        // An example of such prompt may be seen by running: pnpm update --interactive
+        if (!view.endsWith(EOL))
+            view += EOL;
+        write(diff.update(view));
+    }
+    return () => {
+        subscription.unsubscribe();
+    };
+}
+export function toOutput$(opts) {
+    opts = opts || {};
+    const contextPushStream = new Rx.Subject();
+    const fetchingProgressPushStream = new Rx.Subject();
+    const executionTimePushStream = new Rx.Subject();
+    const progressPushStream = new Rx.Subject();
+    const stagePushStream = new Rx.Subject();
+    const deprecationPushStream = new Rx.Subject();
+    const summaryPushStream = new Rx.Subject();
+    const lifecyclePushStream = new Rx.Subject();
+    const statsPushStream = new Rx.Subject();
+    const packageImportMethodPushStream = new Rx.Subject();
+    const installCheckPushStream = new Rx.Subject();
+    const installingConfigDepsStream = new Rx.Subject();
+    const ignoredScriptsPushStream = new Rx.Subject();
+    const registryPushStream = new Rx.Subject();
+    const rootPushStream = new Rx.Subject();
+    const packageManifestPushStream = new Rx.Subject();
+    const peerDependencyIssuesPushStream = new Rx.Subject();
+    const linkPushStream = new Rx.Subject();
+    const otherPushStream = new Rx.Subject();
+    const hookPushStream = new Rx.Subject();
+    const skippedOptionalDependencyPushStream = new Rx.Subject();
+    const scopePushStream = new Rx.Subject();
+    const requestRetryPushStream = new Rx.Subject();
+    const updateCheckPushStream = new Rx.Subject();
+    setTimeout(() => {
+        opts.streamParser.on('data', (log) => {
+            switch (log.name) {
+                case 'pnpm:context':
+                    contextPushStream.next(log);
+                    break;
+                case 'pnpm:execution-time':
+                    executionTimePushStream.next(log);
+                    break;
+                case 'pnpm:fetching-progress':
+                    fetchingProgressPushStream.next(log);
+                    break;
+                case 'pnpm:progress':
+                    progressPushStream.next(log);
+                    break;
+                case 'pnpm:stage':
+                    stagePushStream.next(log);
+                    break;
+                case 'pnpm:deprecation':
+                    deprecationPushStream.next(log);
+                    break;
+                case 'pnpm:summary':
+                    summaryPushStream.next(log);
+                    break;
+                case 'pnpm:lifecycle':
+                    lifecyclePushStream.next(log);
+                    break;
+                case 'pnpm:stats':
+                    statsPushStream.next(log);
+                    break;
+                case 'pnpm:package-import-method':
+                    packageImportMethodPushStream.next(log);
+                    break;
+                case 'pnpm:peer-dependency-issues':
+                    peerDependencyIssuesPushStream.next(log);
+                    break;
+                case 'pnpm:install-check':
+                    installCheckPushStream.next(log);
+                    break;
+                case 'pnpm:installing-config-deps':
+                    installingConfigDepsStream.next(log);
+                    break;
+                case 'pnpm:ignored-scripts':
+                    ignoredScriptsPushStream.next(log);
+                    break;
+                case 'pnpm:registry':
+                    registryPushStream.next(log);
+                    break;
+                case 'pnpm:root':
+                    rootPushStream.next(log);
+                    break;
+                case 'pnpm:package-manifest':
+                    packageManifestPushStream.next(log);
+                    break;
+                case 'pnpm:link':
+                    linkPushStream.next(log);
+                    break;
+                case 'pnpm:hook':
+                    hookPushStream.next(log);
+                    break;
+                case 'pnpm:skipped-optional-dependency':
+                    skippedOptionalDependencyPushStream.next(log);
+                    break;
+                case 'pnpm:scope':
+                    scopePushStream.next(log);
+                    break;
+                case 'pnpm:request-retry':
+                    requestRetryPushStream.next(log);
+                    break;
+                case 'pnpm:update-check':
+                    updateCheckPushStream.next(log);
+                    break;
+                case 'pnpm': // eslint-disable-line
+                case 'pnpm:global': // eslint-disable-line
+                case 'pnpm:store': // eslint-disable-line
+                case 'pnpm:lockfile': // eslint-disable-line
+                    otherPushStream.next(log);
+                    break;
+            }
+        });
+    }, 0);
+    let other = Rx.from(otherPushStream);
+    if (opts.context.config?.hooks?.filterLog != null) {
+        const filterLogs = opts.context.config.hooks.filterLog;
+        const filterFn = filterLogs.length === 1
+            ? filterLogs[0]
+            : (log) => filterLogs.every((filterLog) => filterLog(log));
+        other = other.pipe(filter(filterFn));
+    }
+    const log$ = {
+        context: Rx.from(contextPushStream),
+        deprecation: Rx.from(deprecationPushStream),
+        fetchingProgress: Rx.from(fetchingProgressPushStream),
+        executionTime: Rx.from(executionTimePushStream),
+        hook: Rx.from(hookPushStream),
+        installCheck: Rx.from(installCheckPushStream),
+        installingConfigDeps: Rx.from(installingConfigDepsStream),
+        ignoredScripts: Rx.from(ignoredScriptsPushStream),
+        lifecycle: Rx.from(lifecyclePushStream),
+        link: Rx.from(linkPushStream),
+        other,
+        packageImportMethod: Rx.from(packageImportMethodPushStream),
+        packageManifest: Rx.from(packageManifestPushStream),
+        peerDependencyIssues: Rx.from(peerDependencyIssuesPushStream),
+        progress: Rx.from(progressPushStream),
+        registry: Rx.from(registryPushStream),
+        requestRetry: Rx.from(requestRetryPushStream),
+        root: Rx.from(rootPushStream),
+        scope: Rx.from(scopePushStream),
+        skippedOptionalDependency: Rx.from(skippedOptionalDependencyPushStream),
+        stage: Rx.from(stagePushStream),
+        stats: Rx.from(statsPushStream),
+        summary: Rx.from(summaryPushStream),
+        updateCheck: Rx.from(updateCheckPushStream),
+    };
+    const cmd = opts.context.argv[0];
+    const outputs = reporterForClient(log$, {
+        appendOnly: opts.reportingOptions?.appendOnly,
+        cmd,
+        config: opts.context.config,
+        env: opts.context.env ?? process.env,
+        filterPkgsDiff: opts.filterPkgsDiff,
+        process: opts.context.process ?? process,
+        isRecursive: opts.context.config?.['recursive'] === true,
+        logLevel: opts.reportingOptions?.logLevel,
+        pnpmConfig: opts.context.config,
+        streamLifecycleOutput: opts.reportingOptions?.streamLifecycleOutput,
+        aggregateOutput: opts.reportingOptions?.aggregateOutput,
+        throttleProgress: opts.reportingOptions?.throttleProgress,
+        width: opts.reportingOptions?.outputMaxWidth,
+        hideAddedPkgsProgress: opts.reportingOptions?.hideAddedPkgsProgress,
+        hideProgressPrefix: opts.reportingOptions?.hideProgressPrefix ?? (cmd === 'dlx' || opts.context.config?.global === true),
+        hideLifecycleOutput: opts.reportingOptions?.hideLifecycleOutput,
+        hideLifecyclePrefix: opts.reportingOptions?.hideLifecyclePrefix,
+        approveBuildsInstructionText: opts.reportingOptions?.approveBuildsInstructionText,
+    });
+    if (opts.reportingOptions?.appendOnly) {
+        return Rx.merge(...outputs)
+            .pipe(map((log) => log.pipe(map((msg) => msg.msg))), mergeAll());
+    }
+    return mergeOutputs(outputs);
+}
+//# sourceMappingURL=index.js.map

package/lib/mergeOutputs.d.ts

@@ -0,0 +1,4 @@
+import * as Rx from 'rxjs';
+export declare function mergeOutputs(outputs: Array<Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>>): Rx.Observable<string>;

package/lib/mergeOutputs.js

@@ -0,0 +1,69 @@
+import * as Rx from 'rxjs';
+import { filter, map, mergeAll, scan } from 'rxjs/operators';
+import { EOL } from './constants.js';
+export function mergeOutputs(outputs) {
+    let blockNo = 0;
+    let fixedBlockNo = 0;
+    let started = false;
+    let previousOutput = null;
+    return Rx.merge(...outputs).pipe(map((log) => {
+        let currentBlockNo = -1;
+        let currentFixedBlockNo = -1;
+        return log.pipe(map((msg) => {
+            if (msg.fixed) {
+                if (currentFixedBlockNo === -1) {
+                    currentFixedBlockNo = fixedBlockNo++;
+                }
+                return {
+                    blockNo: currentFixedBlockNo,
+                    fixed: true,
+                    msg: msg.msg,
+                };
+            }
+            if (currentBlockNo === -1) {
+                currentBlockNo = blockNo++;
+            }
+            return {
+                blockNo: currentBlockNo,
+                fixed: false,
+                msg: typeof msg === 'string' ? msg : msg.msg, // eslint-disable-line
+                prevFixedBlockNo: currentFixedBlockNo,
+            };
+        }));
+    }), mergeAll(), scan((acc, log) => {
+        if (log.fixed) {
+            acc.fixedBlocks[log.blockNo] = log.msg;
+        }
+        else {
+            delete acc.fixedBlocks[log.prevFixedBlockNo];
+            acc.blocks[log.blockNo] = log.msg;
+        }
+        return acc;
+    }, { fixedBlocks: [], blocks: [] }), map((sections) => {
+        const fixedBlocks = sections.fixedBlocks.filter(Boolean);
+        const nonFixedPart = sections.blocks.filter(Boolean).join(EOL);
+        if (fixedBlocks.length === 0) {
+            return nonFixedPart;
+        }
+        const fixedPart = fixedBlocks.join(EOL);
+        if (!nonFixedPart) {
+            return fixedPart;
+        }
+        return `${nonFixedPart}${EOL}${fixedPart}`;
+    }), filter((msg) => {
+        if (started) {
+            return true;
+        }
+        if (msg === '')
+            return false;
+        started = true;
+        return true;
+    }), filter((msg) => {
+        if (msg !== previousOutput) {
+            previousOutput = msg;
+            return true;
+        }
+        return false;
+    }));
+}
+//# sourceMappingURL=mergeOutputs.js.map

package/lib/reportError.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '@pnpm/config.reader';
+import type { Log } from '@pnpm/core-loggers';
+export declare function reportError(logObj: Log, config?: Config): string | null;