enigma-bbs/core/word_wrap.js

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

const { ansiRenderStringLength } = require('./string_util');

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

exports.wordWrapText = wordWrapText;

const SPACE_CHARS = [
    ' ',
    '\f',
    '\n',
    '\r',
    '\v',
    '​\u00a0',
    '\u1680',
    '​\u180e',
    '\u2000​',
    '\u2001',
    '\u2002',
    '​\u2003',
    '\u2004',
    '\u2005',
    '\u2006​',
    '\u2007',
    '\u2008​',
    '\u2009',
    '\u200a​',
    '\u2028',
    '\u2029​',
    '\u202f',
    '\u205f​',
    '\u3000',
];

const REGEXP_WORD_WRAP = new RegExp(`\t|[${SPACE_CHARS.join('')}]`, 'g');

function wordWrapText(text, options) {
    assert(_.isObject(options));
    assert(_.isNumber(options.width));

    options.tabHandling = options.tabHandling || 'expand';
    options.tabWidth = options.tabWidth || 4;
    options.tabChar = options.tabChar || ' ';

    //const REGEXP_GOBBLE = new RegExp(`.{0,${options.width}}`, 'g');
    //
    //  For a given word, match 0->options.width chars -- always include a full trailing ESC
    //  sequence if present!
    //
    //  :TODO: Need to create ansi.getMatchRegex or something - this is used all over
    const REGEXP_GOBBLE = new RegExp(
        `.{0,${options.width}}\\x1b\\[[\\?=;0-9]*[ABCDEFGHJKLMSTfhlmnprsu]|.{0,${options.width}}`,
        'g'
    );

    let m;
    let word;
    let c;
    let renderLen;
    let i = 0;
    let wordStart = 0;
    let result = { wrapped: [''], renderLen: [0] };

    function expandTab(column) {
        const remainWidth = options.tabWidth - (column % options.tabWidth);
        return new Array(remainWidth).join(options.tabChar);
    }

    function appendWord() {
        word.match(REGEXP_GOBBLE).forEach(w => {
            renderLen = ansiRenderStringLength(w);

            if (result.renderLen[i] + renderLen > options.width) {
                if (0 === i) {
                    result.firstWrapRange = {
                        start: wordStart,
                        end: wordStart + w.length,
                    };
                }

                result.wrapped[++i] = w;
                result.renderLen[i] = renderLen;
            } else {
                result.wrapped[i] += w;
                result.renderLen[i] = (result.renderLen[i] || 0) + renderLen;
            }
        });
    }

    //
    //  Some of the way we word wrap is modeled after Sublime Test 3:
    //
    //  *   Sublime Text 3 for example considers spaces after a word
    //      part of said word. For example, "word    " would be wraped
    //      in it's entirety.
    //
    //  *   Tabs in Sublime Text 3 are also treated as a word, so, e.g.
    //      "\t" may resolve to "      " and must fit within the space.
    //
    //  *   If a word is ultimately too long to fit, break it up until it does.
    //
    while (null !== (m = REGEXP_WORD_WRAP.exec(text))) {
        word = text.substring(wordStart, REGEXP_WORD_WRAP.lastIndex - 1);

        c = m[0].charAt(0);
        if (SPACE_CHARS.indexOf(c) > -1) {
            word += m[0];
        } else if ('\t' === c) {
            if ('expand' === options.tabHandling) {
                //  Good info here: http://c-for-dummies.com/blog/?p=424
                word +=
                    expandTab(result.wrapped[i].length + word.length) + options.tabChar;
            } else {
                word += m[0];
            }
        }

        appendWord();
        wordStart = REGEXP_WORD_WRAP.lastIndex + m[0].length - 1;
    }

    word = text.substring(wordStart);
    appendWord();

    return result;
}