enigma-bbs/core/ansi_prep.js

/* jslint node: true */
'use strict';

//  ENiGMA½
const ANSIEscapeParser  = require('./ansi_escape_parser.js').ANSIEscapeParser;
const ANSI              = require('./ansi_term.js');
const {
    splitTextAtTerms,
    renderStringLength
}                       = require('./string_util.js');

//  deps
const _                 = require('lodash');

module.exports = function ansiPrep(input, options, cb) {
    if(!input) {
        return cb(null, '');
    }

    options.termWidth           = options.termWidth     || 80;
    options.termHeight          = options.termHeight    || 25;
    options.cols                = options.cols || options.termWidth     || 80;
    options.rows                = options.rows || options.termHeight    || 'auto';
    options.startCol            = options.startCol || 1;
    options.exportMode          = options.exportMode || false;
    options.fillLines           = _.get(options, 'fillLines', true);
    options.indent              = options.indent || 0;

    //  in auto we start out at 25 rows, but can always expand for more
    const canvas = Array.from( { length : 'auto' === options.rows ? 25 : options.rows }, () => Array.from( { length : options.cols}, () => new Object() ) );
    const parser = new ANSIEscapeParser( { termHeight : options.termHeight, termWidth : options.termWidth } );

    const state = {
        row : 0,
        col : 0,
    };

    let lastRow = 0;

    function ensureRow(row) {
        if(canvas[row]) {
            return;
        }

        canvas[row] = Array.from( { length : options.cols}, () => new Object() );
    }

    parser.on('position update', (row, col) => {
        state.row   = row - 1;
        state.col   = col - 1;

        if(0 === state.col) {
            state.initialSgr = state.lastSgr;
        }

        lastRow     = Math.max(state.row, lastRow);
    });

    parser.on('literal', literal => {
        //
        //  CR/LF are handled for 'position update'; we don't need the chars themselves
        //
        literal = literal.replace(/\r?\n|[\r\u2028\u2029]/g, '');

        for(let c of literal) {
            if(state.col < options.cols && ('auto' === options.rows || state.row < options.rows)) {
                ensureRow(state.row);

                if(0 === state.col) {
                    canvas[state.row][state.col].initialSgr = state.initialSgr;
                }

                canvas[state.row][state.col].char = c;

                if(state.sgr) {
                    canvas[state.row][state.col].sgr    = _.clone(state.sgr);
                    state.lastSgr                       = canvas[state.row][state.col].sgr;
                    state.sgr                           = null;
                }
            }

            state.col += 1;
        }
    });

    parser.on('sgr update', sgr => {
        ensureRow(state.row);

        if(state.col < options.cols) {
            canvas[state.row][state.col].sgr    = _.clone(sgr);
            state.lastSgr                       = canvas[state.row][state.col].sgr;
        } else {
            state.sgr = sgr;
        }
    });

    function getLastPopulatedColumn(row) {
        let col = row.length;
        while(--col > 0) {
            if(row[col].char || row[col].sgr) {
                break;
            }
        }
        return col;
    }

    parser.on('complete', () => {
        let output = '';
        let line;
        let sgr;

        canvas.slice(0, lastRow + 1).forEach(row => {
            const lastCol = getLastPopulatedColumn(row) + 1;

            let i;
            line = options.indent ?
                output.length > 0 ? ' '.repeat(options.indent) : '' :
                '';

            for(i = 0; i < lastCol; ++i) {
                const col = row[i];

                sgr = !options.asciiMode && 0 === i ?
                    col.initialSgr ? ANSI.getSGRFromGraphicRendition(col.initialSgr) : '' :
                    '';

                if(!options.asciiMode && col.sgr) {
                    sgr += ANSI.getSGRFromGraphicRendition(col.sgr);
                }

                line += `${sgr}${col.char || ' '}`;
            }

            output += line;

            if(i < row.length) {
                output += `${options.asciiMode ? '' : ANSI.blackBG()}`;
                if(options.fillLines) {
                    output += `${row.slice(i).map( () => ' ').join('')}`;//${lastSgr}`;
                }
            }

            if(options.startCol + i < options.termWidth || options.forceLineTerm) {
                output += '\r\n';
            }
        });

        if(options.exportMode) {
            //
            //  If we're in export mode, we do some additional hackery:
            //
            //  * Hard wrap ALL lines at <= 79 *characters* (not visible columns)
            //    if a line must wrap early, we'll place a ESC[A ESC[<N>C where <N>
            //    represents chars to get back to the position we were previously at
            //
            //  * Replace contig spaces with ESC[<N>C as well to save... space.
            //
            //  :TODO: this would be better to do as part of the processing above, but this will do for now
            const MAX_CHARS = 79 - 8;   //  79 max, - 8 for max ESC seq's we may prefix a line with
            let exportOutput = '';

            let m;
            let afterSeq;
            let wantMore;
            let renderStart;

            splitTextAtTerms(output).forEach(fullLine => {
                renderStart = 0;

                while(fullLine.length > 0) {
                    let splitAt;
                    const ANSI_REGEXP = ANSI.getFullMatchRegExp();
                    wantMore = true;

                    while((m = ANSI_REGEXP.exec(fullLine))) {
                        afterSeq = m.index + m[0].length;

                        if(afterSeq < MAX_CHARS) {
                            //  after current seq
                            splitAt = afterSeq;
                        } else {
                            if(m.index < MAX_CHARS) {
                                //  before last found seq
                                splitAt = m.index;
                                wantMore = false;   //  can't eat up any more
                            }

                            break;  //  seq's beyond this point are >= MAX_CHARS
                        }
                    }

                    if(splitAt) {
                        if(wantMore) {
                            splitAt = Math.min(fullLine.length, MAX_CHARS - 1);
                        }
                    } else {
                        splitAt = Math.min(fullLine.length, MAX_CHARS - 1);
                    }

                    const part = fullLine.slice(0, splitAt);
                    fullLine = fullLine.slice(splitAt);
                    renderStart += renderStringLength(part);
                    exportOutput += `${part}\r\n`;

                    if(fullLine.length > 0) {   //  more to go for this line?
                        exportOutput += `${ANSI.up()}${ANSI.right(renderStart)}`;
                    } else {
                        exportOutput += ANSI.up();
                    }
                }
            });

            return cb(null, exportOutput);
        }

        return cb(null, output);
    });

    parser.parse(input);
};