sfdx-jayree 4.4.38 → 4.5.1

package/lib/utils/renderer.js

@@ -1,148 +1,202 @@
 /*
- * Copyright (c) 2021, jayree
+ * Copyright (c) 2022, jayree
  * All rights reserved.
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 import { EOL } from 'os';
-import cliTruncate from 'cli-truncate';
-import logUpdate from 'log-update';
-import cliWrap from 'wrap-ansi';
-import { figures } from 'listr2';
-import { createColors } from 'colorette';
-const colorette = createColors({ useColor: process.env?.LISTR_DISABLE_COLOR !== '1' });
-function indentString(string, count) {
-    return string.replace(/^(?!\s*$)/gm, ' '.repeat(count));
-}
-function isUnicodeSupported() {
-    if (process.platform !== 'win32') {
-        return true;
-    }
-    /* istanbul ignore next */
-    return (Boolean(process.env.CI) ||
-        Boolean(process.env.WT_SESSION) ||
-        process.env.TERM_PROGRAM === 'vscode' ||
-        process.env.TERM === 'xterm-256color' ||
-        process.env.TERM === 'alacritty');
-}
-function parseTaskTime(duration) {
-    const seconds = Math.floor(duration / 1000);
-    const minutes = Math.floor(seconds / 60);
-    let parsedTime;
-    if (seconds === 0 && minutes === 0) {
-        parsedTime = `0.${Math.floor(duration / 100)}s`;
-    }
-    if (seconds > 0) {
-        parsedTime = `${seconds % 60}s`;
-    }
-    if (minutes > 0) {
-        parsedTime = `${minutes}m${parsedTime}`;
-    }
-    return parsedTime;
-}
+import { ListrEventType, ListrTaskEventType, ListrTaskState, PromptError, PRESET_TIMER, ListrLogger, ListrLogLevels, ProcessOutputBuffer, Spinner, assertFunctionOrSelf, cleanseAnsi, color, indent, LISTR_DEFAULT_RENDERER_STYLE, ListrDefaultRendererLogLevels, } from 'listr2';
 function startTimeSpan() {
     const start = process.hrtime.bigint();
     return { getTimeSpan: () => Number(process.hrtime.bigint() - start) / 1000000000 };
 }
-/** Default updating renderer for Listr2 */
-export class MyDefaultRenderer {
-    constructor(tasks, options, renderHook$) {
+class MyDefaultRenderer {
+    constructor(tasks, options, events) {
         this.tasks = tasks;
         this.options = options;
-        this.renderHook$ = renderHook$;
-        this.bottomBar = {};
-        this.spinner = !isUnicodeSupported()
-            ? ['-', '\\', '|', '/']
-            : ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        this.spinnerPosition = 0;
+        this.events = events;
+        this.bottom = new Map();
         this.taskTime = {};
         this.currentTasks = {};
         this.hiddenTasks = {};
-        this.options = { ...MyDefaultRenderer.rendererOptions, ...this.options };
+        this.options = {
+            ...MyDefaultRenderer.rendererOptions,
+            ...this.options,
+            icon: {
+                ...LISTR_DEFAULT_RENDERER_STYLE.icon,
+                ...(options?.icon ?? {}),
+            },
+            color: {
+                ...LISTR_DEFAULT_RENDERER_STYLE.color,
+                ...(options?.color ?? {}),
+            },
+        };
+        this.spinner = this.options.spinner ?? new Spinner();
+        this.logger =
+            this.options.logger ?? new ListrLogger({ useIcons: true, toStderr: [] });
+        this.logger.options.icon = this.options.icon;
+        this.logger.options.color = this.options.color;
     }
-    static getTaskOptions(task) {
+    // eslint-disable-next-line class-methods-use-this
+    getTaskOptions(task) {
         return { ...MyDefaultRenderer.rendererTaskOptions, ...task.rendererTaskOptions };
     }
-    static isBottomBar(task) {
-        const bottomBar = MyDefaultRenderer.getTaskOptions(task).bottomBar;
-        return ((typeof bottomBar === 'number' && bottomBar !== 0) || (typeof bottomBar === 'boolean' && bottomBar !== false));
-    }
-    static hasPersistentOutput(task) {
-        return MyDefaultRenderer.getTaskOptions(task).persistentOutput === true;
+    isBottomBar(task) {
+        const bottomBar = this.getTaskOptions(task).bottomBar;
+        return ((typeof bottomBar === 'number' && bottomBar !== 0) ||
+            (typeof bottomBar === 'boolean' && bottomBar !== false) ||
+            !task.hasTitle());
     }
-    static hasTimer(task) {
-        return MyDefaultRenderer.getTaskOptions(task).showTimer === true;
+    hasPersistentOutput(task) {
+        return this.getTaskOptions(task).persistentOutput === true;
     }
-    /* istanbul ignore next */
-    static getTaskTime(task) {
-        return colorette.dim(`[${parseTaskTime(task.message.duration)}]`);
+    getSelfOrParentOption(task, key) {
+        return task?.rendererOptions?.[key] ?? this.options?.[key];
     }
-    static indentMultilineOutput(str, i) {
-        return i > 0 ? indentString(str.trim(), 2) : str.trim();
+    async render() {
+        const { createLogUpdate } = await import('log-update');
+        const { default: truncate } = await import('cli-truncate');
+        const { default: wrap } = await import('wrap-ansi');
+        this.updater = createLogUpdate(this.logger.process.stdout);
+        this.truncate = truncate;
+        this.wrap = wrap;
+        this.logger.process.hijack();
+        /* istanbul ignore if */
+        if (!this.options?.lazy) {
+            this.spinner.start(() => {
+                this.update();
+            });
+        }
+        this.events.on(ListrEventType.SHOULD_REFRESH_RENDER, () => {
+            this.update();
+        });
     }
-    static addSuffixToMessage(message, suffix, condition) {
-        return condition ?? true ? message + colorette.dim(` [${suffix}]`) : message;
+    update() {
+        this.updater(this.create());
     }
-    getSelfOrParentOption(task, key) {
-        return task?.rendererOptions?.[key] ?? this.options?.[key];
+    end() {
+        this.spinner.stop();
+        // clear log updater
+        this.updater.clear();
+        this.updater.done();
+        // directly write to process.stdout, since logupdate only can update the seen height of terminal
+        if (!this.options.clearOutput) {
+            this.logger.process.toStdout(this.create({ prompt: false }));
+        }
+        this.logger.process.release();
     }
-    createRender(options) {
+    create(options) {
         options = {
-            ...{
-                tasks: true,
-                bottomBar: true,
-                prompt: true,
-            },
+            tasks: true,
+            bottomBar: true,
+            prompt: true,
             ...options,
         };
         const render = [];
-        const renderTasks = this.multiLineRenderer(this.tasks);
+        const renderTasks = this.renderer(this.tasks);
         const renderBottomBar = this.renderBottomBar();
         const renderPrompt = this.renderPrompt();
-        if (options.tasks && renderTasks?.trim().length > 0) {
-            render.push(renderTasks);
+        if (options.tasks && renderTasks.length > 0) {
+            render.push(...renderTasks);
         }
-        if (options.bottomBar && renderBottomBar?.trim().length > 0) {
-            render.push((render.length > 0 ? EOL : '') + renderBottomBar);
+        if (options.bottomBar && renderBottomBar.length > 0) {
+            if (render.length > 0) {
+                render.push('');
+            }
+            render.push(...renderBottomBar);
         }
-        if (options.prompt && renderPrompt?.trim().length > 0) {
-            render.push((render.length > 0 ? EOL : '') + renderPrompt);
+        if (options.prompt && renderPrompt.length > 0) {
+            if (render.length > 0) {
+                render.push('');
+            }
+            render.push(...renderPrompt);
         }
-        return render.length > 0 ? render.join(EOL) : '';
+        return render.join(EOL);
     }
-    render() {
-        // Do not render if we are already rendering
-        if (this.id) {
-            return;
+    // eslint-disable-next-line complexity
+    style(task, output = false) {
+        if (task.isSkipped()) {
+            if (output || this.getSelfOrParentOption(task, 'collapseSkips')) {
+                return this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE);
+            }
+            else if (this.getSelfOrParentOption(task, 'collapseSkips') === false) {
+                return this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITHOUT_COLLAPSE);
+            }
         }
-        const updateRender = () => logUpdate(this.createRender());
-        /* istanbul ignore if */
-        if (!this.options?.lazy) {
-            this.id = setInterval(() => {
-                this.spinnerPosition = ++this.spinnerPosition % this.spinner.length;
-                updateRender();
-            }, 100);
+        if (output) {
+            if (this.isBottomBar(task)) {
+                return this.logger.icon(ListrDefaultRendererLogLevels.OUTPUT_WITH_BOTTOMBAR);
+            }
+            return this.logger.icon(ListrDefaultRendererLogLevels.OUTPUT);
         }
-        this.renderHook$.subscribe(() => {
-            updateRender();
-        });
+        if (task.hasSubtasks()) {
+            if (task.isStarted() ||
+                (task.isPrompt() &&
+                    this.getSelfOrParentOption(task, 'showSubtasks') !== false &&
+                    !task.subtasks.every((subtask) => !subtask.hasTitle()))) {
+                return this.logger.icon(ListrDefaultRendererLogLevels.PENDING);
+            }
+            else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) {
+                return this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SUBTASKS);
+            }
+            else if (task.hasFailed()) {
+                return this.logger.icon(ListrDefaultRendererLogLevels.FAILED_WITH_FAILED_SUBTASKS);
+            }
+        }
+        if (task.isStarted() || task.isPrompt()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.PENDING, !this.options?.lazy && this.spinner.fetch());
+        }
+        else if (task.isCompleted()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED);
+        }
+        else if (task.isRetrying()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.RETRY, !this.options?.lazy && this.spinner.fetch());
+        }
+        else if (task.isRollingBack()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.ROLLING_BACK, !this.options?.lazy && this.spinner.fetch());
+        }
+        else if (task.hasRolledBack()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.ROLLED_BACK);
+        }
+        else if (task.hasFailed()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.FAILED);
+        }
+        else if (task.isPaused()) {
+            return this.logger.icon(ListrDefaultRendererLogLevels.PAUSED);
+        }
+        return this.logger.icon(ListrDefaultRendererLogLevels.WAITING);
     }
-    end() {
-        clearInterval(this.id);
-        if (this.id) {
-            this.id = undefined;
+    format(message, icon, level) {
+        // we dont like empty data around here
+        if (message.trim() === '') {
+            return [];
         }
-        // clear log updater
-        logUpdate.clear();
-        logUpdate.done();
-        // directly write to process.stdout, since logupdate only can update the seen height of terminal
-        if (!this.options.clearOutput) {
-            process.stdout.write(this.createRender({ prompt: false }) + EOL);
+        if (icon) {
+            message = icon + ' ' + message;
+        }
+        let parsed;
+        const columns = (process.stdout.columns ?? 80) - level * this.options.indentation - 2;
+        switch (this.options.formatOutput) {
+            case 'truncate':
+                parsed = message.split(EOL).map((s, i) => this.truncate(this.indent(s, i), columns));
+                break;
+            case 'wrap':
+                parsed = this.wrap(message, columns, { hard: true })
+                    .split(EOL)
+                    .map((s, i) => this.indent(s, i));
+                break;
+            default:
+                throw new Error('Format option for the renderer is wrong.');
+        }
+        // this removes the empty lines
+        if (this.options.removeEmptyLines) {
+            parsed = parsed.filter(Boolean);
         }
+        return parsed.map((str) => indent(str, level * this.options.indentation));
     }
-    // eslint-disable-next-line
-    multiLineRenderer(tasks, id = 'root', level = 0) {
-        let output = [];
+    renderer(tasks, id = 'root', level = 0) {
+        const preOutput = [];
+        const postOutput = [];
         if (!this.taskTime[id]) {
             this.taskTime[id] = {};
         }
@@ -159,29 +213,55 @@ export class MyDefaultRenderer {
         if (this.hiddenTasks[id].length > 0 && tasks.filter((t) => t.isPending()).length !== 0) {
             const completed = this.hiddenTasks[id].filter((t) => t.isCompleted());
             if (completed.length > 0) {
-                output = [
-                    ...output,
-                    this.formatString(`... completed (${completed.length})`, colorette.green(figures.tick), level),
-                ];
+                preOutput.push(...this.format(`... completed (${completed.length})`, this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED), level));
             }
             const failed = this.hiddenTasks[id].filter((t) => t.hasFailed());
             if (failed.length > 0) {
-                output = [...output, this.formatString(`... failed (${failed.length})`, colorette.red(figures.cross), level)];
+                preOutput.push(...this.format(`... failed (${failed.length})`, this.logger.icon(ListrDefaultRendererLogLevels.FAILED), level));
             }
             const skipped = this.hiddenTasks[id].filter((t) => t.isSkipped());
             if (skipped.length > 0) {
-                output = [
-                    ...output,
-                    this.formatString(`... skipped (${skipped.length})`, colorette.yellow(figures.arrowDown), level),
-                ];
+                preOutput.push(...this.format(`... skipped (${skipped.length})`, this.logger.icon(ListrDefaultRendererLogLevels.SKIPPED_WITH_COLLAPSE), level));
             }
         }
-        for (const task of tasks) {
-            const idx = this.currentTasks[id].findIndex((x) => x.title === task.title);
-            if ((idx >= 0 && idx <= this.options.maxSubTasks - 1) ||
-                level === 0 ||
-                tasks.filter((t) => t.isPending() || typeof t.state === 'undefined').length === 0) {
-                if (task.isEnabled()) {
+        if (level > 0 &&
+            this.currentTasks[id].length - this.options.maxSubTasks > 0 &&
+            tasks.filter((t) => t.isPending()).length !== 0) {
+            postOutput.push(...this.format(`... waiting (${this.currentTasks[id].length - this.options.maxSubTasks})`, this.logger.icon(ListrDefaultRendererLogLevels.WAITING), level));
+        }
+        return [
+            ...preOutput,
+            // eslint-disable-next-line complexity
+            ...tasks.flatMap((task) => {
+                const output = [];
+                const idx = this.currentTasks[id].findIndex((x) => x.title === task.title);
+                if ((idx >= 0 && idx <= this.options.maxSubTasks - 1) ||
+                    level === 0 ||
+                    tasks.filter((t) => t.isPending() || typeof t.state === 'undefined').length === 0) {
+                    if (!task.isEnabled()) {
+                        return [];
+                    }
+                    if (task.isPrompt()) {
+                        if (this.activePrompt && this.activePrompt !== task.id) {
+                            throw new PromptError('Only one prompt can be active at the given time, please reevaluate your task design.');
+                        }
+                        else if (!this.activePrompt) {
+                            task.on(ListrTaskEventType.PROMPT, (prompt) => {
+                                const cleansed = cleanseAnsi(prompt);
+                                if (cleansed) {
+                                    this.prompt = cleansed;
+                                }
+                            });
+                            task.on(ListrTaskEventType.STATE, (state) => {
+                                if (state === ListrTaskState.PROMPT_COMPLETED || task.hasFinalized() || task.hasReset()) {
+                                    this.prompt = null;
+                                    this.activePrompt = null;
+                                    task.off(ListrTaskEventType.PROMPT);
+                                }
+                            });
+                            this.activePrompt = task.id;
+                        }
+                    }
                     // Current Task Title
                     if (task.hasTitle()) {
                         if (!(tasks.some(
@@ -193,45 +273,50 @@ export class MyDefaultRenderer {
                             // if task is skipped
                             if (task.hasFailed() && this.getSelfOrParentOption(task, 'collapseErrors')) {
                                 // current task title and skip change the title
-                                output = [
-                                    ...output,
-                                    this.formatString(!task.hasSubtasks() && task.message.error && this.getSelfOrParentOption(task, 'showErrorMessage')
-                                        ? task.message.error
-                                        : task.title, this.getSymbol(task), level),
-                                ];
+                                output.push(...this.format(!task.hasSubtasks() && task.message.error && this.getSelfOrParentOption(task, 'showErrorMessage')
+                                    ? task.message.error
+                                    : task.title, this.style(task), level));
                             }
                             else if (task.isSkipped() && this.getSelfOrParentOption(task, 'collapseSkips')) {
                                 // current task title and skip change the title
-                                output = [
-                                    ...output,
-                                    this.formatString(MyDefaultRenderer.addSuffixToMessage(task.message.skip && this.getSelfOrParentOption(task, 'showSkipMessage')
-                                        ? task.message.skip
-                                        : task.title, 'SKIPPED', this.getSelfOrParentOption(task, 'suffixSkips')), this.getSymbol(task), level),
-                                ];
+                                output.push(...this.format(this.logger.suffix(task.message.skip && this.getSelfOrParentOption(task, 'showSkipMessage')
+                                    ? task.message.skip
+                                    : task.title, {
+                                    field: ListrLogLevels.SKIPPED,
+                                    condition: this.getSelfOrParentOption(task, 'suffixSkips'),
+                                    format: () => color.dim,
+                                }), this.style(task), level));
                             }
-                            else if (task.isRetrying() && this.getSelfOrParentOption(task, 'suffixRetries')) {
-                                output = [
-                                    ...output,
-                                    this.formatString(MyDefaultRenderer.addSuffixToMessage(task.title, `RETRYING-${task.message.retry.count}`), this.getSymbol(task), level),
-                                ];
+                            else if (task.isRetrying()) {
+                                output.push(...this.format(this.logger.suffix(task.title, {
+                                    field: `${ListrLogLevels.RETRY}:${task.message.retry.count}`,
+                                    format: () => color.yellow,
+                                    condition: this.getSelfOrParentOption(task, 'suffixRetries'),
+                                }), this.style(task), level));
                             }
                             else if (task.isCompleted() &&
                                 task.hasTitle() &&
-                                (this.getSelfOrParentOption(task, 'showTimer') || MyDefaultRenderer.hasTimer(task))) {
+                                assertFunctionOrSelf(this.getSelfOrParentOption(task, 'timer')?.condition, task.message.duration)) {
                                 // task with timer
-                                output = [
-                                    ...output,
-                                    this.formatString(`${task?.title} ${MyDefaultRenderer.getTaskTime(task)}`, this.getSymbol(task), level),
-                                ];
+                                output.push(...this.format(this.logger.suffix(task?.title, {
+                                    ...this.getSelfOrParentOption(task, 'timer'),
+                                    args: [task.message.duration],
+                                }), this.style(task), level));
+                            }
+                            else if (task.isPaused()) {
+                                output.push(...this.format(this.logger.suffix(task.title, {
+                                    ...PRESET_TIMER,
+                                    args: [task.message.paused - Date.now()],
+                                }), this.style(task), level));
                             }
                             else {
                                 // normal state
-                                output = [...output, this.formatString(task.title, this.getSymbol(task), level)];
+                                output.push(...this.format(task.title, this.style(task), level));
                             }
                         }
                         else {
                             // some sibling task but self has failed and this has stopped
-                            output = [...output, this.formatString(task.title, colorette.red(figures.squareSmallFilled), level)];
+                            output.push(...this.format(task.title, this.logger.icon(ListrDefaultRendererLogLevels.COMPLETED_WITH_FAILED_SISTER_TASKS), level));
                         }
                     }
                     // task should not have subtasks since subtasks will handle the error already
@@ -243,47 +328,32 @@ export class MyDefaultRenderer {
                             (this.getSelfOrParentOption(task, 'showErrorMessage') ||
                                 !this.getSelfOrParentOption(task, 'showSubtasks'))) {
                             // show skip data if collapsing is not defined
-                            output = [...output, this.dumpData(task, level, 'error')];
+                            output.push(...this.dump(task, level, ListrLogLevels.FAILED));
                         }
                         else if (task.isSkipped() &&
                             this.getSelfOrParentOption(task, 'collapseSkips') === false &&
                             (this.getSelfOrParentOption(task, 'showSkipMessage') || !this.getSelfOrParentOption(task, 'showSubtasks'))) {
                             // show skip data if collapsing is not defined
-                            output = [...output, this.dumpData(task, level, 'skip')];
+                            output.push(...this.dump(task, level, ListrLogLevels.SKIPPED));
                         }
                     }
                     // Current Task Output
                     if (task?.output) {
-                        if ((task.isPending() || task.isRetrying() || task.isRollingBack()) && task.isPrompt()) {
-                            // data output to prompt bar if prompt
-                            this.promptBar = task.output;
-                        }
-                        else if (MyDefaultRenderer.isBottomBar(task) || !task.hasTitle()) {
-                            // data output to bottom bar
-                            const data = [this.dumpData(task, -1)];
+                        if (this.isBottomBar(task)) {
                             // create new if there is no persistent storage created for bottom bar
-                            if (!this.bottomBar[task.id]) {
-                                this.bottomBar[task.id] = {};
-                                this.bottomBar[task.id].data = [];
-                                const bottomBar = MyDefaultRenderer.getTaskOptions(task).bottomBar;
-                                if (typeof bottomBar === 'boolean') {
-                                    this.bottomBar[task.id].items = 1;
-                                }
-                                else {
-                                    this.bottomBar[task.id].items = bottomBar;
-                                }
-                            }
-                            // persistent bottom bar and limit items in it
-                            if (!this.bottomBar[task.id]?.data?.some((element) => data.includes(element)) && !task.isSkipped()) {
-                                this.bottomBar[task.id].data = [...this.bottomBar[task.id].data, ...data];
+                            if (!this.bottom.has(task.id)) {
+                                const bottomBar = this.getTaskOptions(task).bottomBar;
+                                this.bottom.set(task.id, new ProcessOutputBuffer({ limit: typeof bottomBar === 'boolean' ? 1 : bottomBar }));
+                                // eslint-disable-next-line @typescript-eslint/no-shadow
+                                task.on(ListrTaskEventType.OUTPUT, (output) => {
+                                    const data = this.dump(task, -1, ListrLogLevels.OUTPUT, output);
+                                    this.bottom.get(task.id).write(data.join(EOL));
+                                });
                             }
                         }
-                        else if (task.isPending() ||
-                            task.isRetrying() ||
-                            task.isRollingBack() ||
-                            MyDefaultRenderer.hasPersistentOutput(task)) {
+                        else if (task.isPending() || this.hasPersistentOutput(task)) {
                             // keep output if persistent output is set
-                            output = [...output, this.dumpData(task, level)];
+                            output.push(...this.dump(task, level));
                         }
                     }
                     // render subtasks, some complicated conditionals going on
@@ -293,14 +363,13 @@ export class MyDefaultRenderer {
                         // if it doesnt have subtasks no need to check
                         task.hasSubtasks() &&
                         (task.isPending() ||
-                            task.hasFailed() ||
-                            (task.isCompleted() && !task.hasTitle()) ||
+                            (task.hasFinalized() && !task.hasTitle()) ||
                             // have to be completed and have subtasks
                             (task.isCompleted() &&
-                                this.getSelfOrParentOption(task, 'collapse') === false &&
-                                !task.subtasks.some((subtask) => subtask.rendererOptions.collapse === true)) ||
+                                this.getSelfOrParentOption(task, 'collapseSubtasks') === false &&
+                                !task.subtasks.some((subtask) => subtask.rendererOptions.collapseSubtasks === true)) ||
                             // if any of the subtasks have the collapse option of
-                            task.subtasks.some((subtask) => subtask.rendererOptions.collapse === false) ||
+                            task.subtasks.some((subtask) => subtask.rendererOptions.collapseSubtasks === false) ||
                             // if any of the subtasks has failed
                             task.subtasks.some((subtask) => subtask.hasFailed()) ||
                             // if any of the subtasks rolled back
@@ -308,168 +377,85 @@ export class MyDefaultRenderer {
                         // set level
                         const subtaskLevel = !task.hasTitle() ? level : level + 1;
                         // render the subtasks as in the same way
-                        const subtaskRender = this.multiLineRenderer(task.subtasks, task.id, subtaskLevel);
-                        if (subtaskRender?.trim() !== '' && !task.subtasks.every((subtask) => !subtask.hasTitle())) {
-                            output = [...output, subtaskRender];
-                        }
+                        const subtaskRender = this.renderer(task.subtasks, task.id, subtaskLevel);
+                        output.push(...subtaskRender);
                     }
                     // after task is finished actions
-                    if (task.isCompleted() || task.hasFailed() || task.isSkipped() || task.hasRolledBack()) {
-                        // clean up prompts
-                        this.promptBar = null;
+                    if (task.hasFinalized()) {
                         if (!this.taskTime[id][task.id]) {
                             this.taskTime[id][task.id] = startTimeSpan();
                         }
                         // clean up bottom bar items if not indicated otherwise
-                        if (!MyDefaultRenderer.hasPersistentOutput(task)) {
-                            delete this.bottomBar[task.id];
+                        if (!this.hasPersistentOutput(task)) {
+                            this.bottom.delete(task.id);
                         }
                     }
                 }
-            }
-        }
-        if (level > 0 && this.currentTasks[id].length - this.options.maxSubTasks > 0) {
-            output = [
-                ...output,
-                this.formatString(`... pending (${this.currentTasks[id].length - this.options.maxSubTasks})`, colorette.dim(figures.squareSmallFilled), level),
-            ];
-        }
-        output = output.filter(Boolean);
-        if (output.length > 0) {
-            return output.join(EOL);
-        }
-        else {
-            return;
-        }
+                return output;
+            }),
+            ...postOutput,
+        ];
     }
     renderBottomBar() {
         // parse through all objects return only the last mentioned items
-        if (Object.keys(this.bottomBar).length > 0) {
-            this.bottomBar = Object.keys(this.bottomBar).reduce((o, key) => {
-                if (!o?.[key]) {
-                    o[key] = {};
-                }
-                o[key] = this.bottomBar[key];
-                this.bottomBar[key].data = this.bottomBar[key].data.slice(-this.bottomBar[key].items);
-                o[key].data = this.bottomBar[key].data;
-                return o;
-            }, {});
-            return Object.values(this.bottomBar)
-                .reduce((o, value) => (o = [...o, ...value.data]), [])
-                .filter(Boolean)
-                .join(EOL);
+        if (this.bottom.size === 0) {
+            return [];
         }
+        return Array.from(this.bottom.values())
+            .flatMap((output) => output.all)
+            .sort((a, b) => a.time - b.time)
+            .map((output) => output.entry);
     }
     renderPrompt() {
-        if (this.promptBar) {
-            return this.promptBar;
+        if (!this.prompt) {
+            return [];
         }
+        return [this.prompt];
     }
-    dumpData(task, level, source = 'output') {
-        let data;
-        switch (source) {
-            case 'output':
-                data = task.output;
-                break;
-            case 'skip':
-                data = task.message.skip;
-                break;
-            case 'error':
-                data = task.message.error;
-                break;
+    dump(task, level, source = ListrLogLevels.OUTPUT, data) {
+        if (!data) {
+            switch (source) {
+                case ListrLogLevels.OUTPUT:
+                    data = task.output;
+                    break;
+                case ListrLogLevels.SKIPPED:
+                    data = task.message.skip;
+                    break;
+                case ListrLogLevels.FAILED:
+                    data = task.message.error;
+                    break;
+            }
         }
         // dont return anything on some occasions
-        if (task.hasTitle() && source === 'error' && data === task.title) {
-            return;
+        if ((task.hasTitle() && source === ListrLogLevels.FAILED && data === task.title) || typeof data !== 'string') {
+            return [];
         }
-        if (typeof data === 'string') {
-            return this.formatString(data, this.getSymbol(task, true), level + 1);
+        if (source === ListrLogLevels.OUTPUT) {
+            data = cleanseAnsi(data);
         }
+        return this.format(data, this.style(task, true), level + 1);
     }
-    formatString(str, icon, level) {
-        // we dont like empty data around here
-        if (str.trim() === '') {
-            return;
-        }
-        str = `${icon} ${str}`;
-        let parsedStr;
-        let columns = process.stdout.columns ? process.stdout.columns : 80;
-        columns = columns - level * this.options.indentation - 2;
-        switch (this.options.formatOutput) {
-            case 'truncate':
-                parsedStr = str.split(EOL).map((s, i) => cliTruncate(MyDefaultRenderer.indentMultilineOutput(s, i), columns));
-                break;
-            case 'wrap':
-                parsedStr = cliWrap(str, columns, { hard: true })
-                    .split(EOL)
-                    .map((s, i) => MyDefaultRenderer.indentMultilineOutput(s, i));
-                break;
-            default:
-                throw new Error('Format option for the renderer is wrong.');
-        }
-        // this removes the empty lines
-        if (this.options.removeEmptyLines) {
-            parsedStr = parsedStr.filter(Boolean);
-        }
-        return indentString(parsedStr.join(EOL), level * this.options.indentation);
-    }
-    // eslint-disable-next-line complexity
-    getSymbol(task, data = false) {
-        if (task.isPending() && !data) {
-            return this.options?.lazy ||
-                (this.getSelfOrParentOption(task, 'showSubtasks') !== false &&
-                    task.hasSubtasks() &&
-                    !task.subtasks.every((subtask) => !subtask.hasTitle()))
-                ? colorette.yellow(figures.pointer)
-                : colorette.yellowBright(this.spinner[this.spinnerPosition]);
-        }
-        else if (task.isCompleted() && !data) {
-            return task.hasSubtasks() && task.subtasks.some((subtask) => subtask.hasFailed())
-                ? colorette.yellow(figures.warning)
-                : colorette.green(figures.tick);
-        }
-        else if (task.isRetrying() && !data) {
-            return this.options?.lazy
-                ? colorette.yellow(figures.warning)
-                : colorette.yellow(this.spinner[this.spinnerPosition]);
-        }
-        else if (task.isRollingBack() && !data) {
-            return this.options?.lazy ? colorette.red(figures.warning) : colorette.red(this.spinner[this.spinnerPosition]);
-        }
-        else if (task.hasRolledBack() && !data) {
-            return colorette.red(figures.arrowLeft);
-        }
-        else if (task.hasFailed() && !data) {
-            return task.hasSubtasks() ? colorette.red(figures.pointer) : colorette.red(figures.cross);
-        }
-        else if (task.isSkipped() && !data && this.getSelfOrParentOption(task, 'collapseSkips') === false) {
-            return colorette.yellow(figures.warning);
-        }
-        else if (task.isSkipped() && (data || this.getSelfOrParentOption(task, 'collapseSkips'))) {
-            return colorette.yellow(figures.arrowDown);
-        }
-        return !data ? colorette.dim(figures.squareSmallFilled) : figures.pointerSmall;
+    indent(str, i) {
+        return i > 0 ? indent(str.trim(), this.options.indentation) : str.trim();
     }
 }
-/** designates whether this renderer can output to a non-tty console */
 MyDefaultRenderer.nonTTY = false;
-/** renderer options for the defauult renderer */
 MyDefaultRenderer.rendererOptions = {
     indentation: 2,
     clearOutput: false,
     showSubtasks: true,
-    collapse: true,
+    collapseSubtasks: true,
     collapseSkips: true,
     showSkipMessage: true,
-    suffixSkips: true,
+    suffixSkips: false,
     collapseErrors: true,
     showErrorMessage: true,
     suffixRetries: true,
     lazy: false,
-    showTimer: false,
     removeEmptyLines: true,
-    formatOutput: 'truncate',
+    formatOutput: 'wrap',
     maxSubTasks: 10,
     hideAfterSeconds: 5,
 };
+export { MyDefaultRenderer };
 //# sourceMappingURL=renderer.js.map