Initial commit, 90% there

node_modules/wordwrapjs/index.js

@@ -0,0 +1,149 @@
+'use strict'
+const os = require('os')
+const t = require('typical')
+
+/**
+ * @module wordwrapjs
+ */
+
+const re = {
+  chunk: /[^\s-]+?-\b|\S+|\s+|\r\n?|\n/g,
+  ansiEscapeSequence: /\u001b.*?m/g
+}
+
+/**
+ * @alias module:wordwrapjs
+ * @typicalname wordwrap
+ */
+class WordWrap {
+  constructor (text, options) {
+    options = options || {}
+    if (!t.isDefined(text)) text = ''
+
+    this._lines = String(text).split(/\r\n|\n/g)
+    this.options = options
+    this.options.width = options.width === undefined ? 30 : options.width
+  }
+
+  lines () {
+    const flatten = require('reduce-flatten')
+
+    /* trim each line of the supplied text */
+    return this._lines.map(trimLine.bind(this))
+
+      /* split each line into an array of chunks, else mark it empty */
+      .map(line => line.match(re.chunk) || [ '~~empty~~' ])
+
+      /* optionally, break each word on the line into pieces */
+      .map(lineWords => {
+        if (this.options.break) {
+          return lineWords.map(breakWord.bind(this))
+        } else {
+          return lineWords
+        }
+      })
+      .map(lineWords => lineWords.reduce(flatten, []))
+
+      /* transforming the line of words to one or more new lines wrapped to size */
+      .map(lineWords => {
+        return lineWords
+          .reduce((lines, word) => {
+            let currentLine = lines[lines.length - 1]
+            if (replaceAnsi(word).length + replaceAnsi(currentLine).length > this.options.width) {
+              lines.push(word)
+            } else {
+              lines[lines.length - 1] += word
+            }
+            return lines
+          }, [ '' ])
+      })
+      .reduce(flatten, [])
+
+      /* trim the wrapped lines */
+      .map(trimLine.bind(this))
+
+      /* filter out empty lines */
+      .filter(line => line.trim())
+
+      /* restore the user's original empty lines */
+      .map(line => line.replace('~~empty~~', ''))
+  }
+
+  wrap () {
+    return this.lines().join(os.EOL)
+  }
+
+  toString () {
+    return this.wrap()
+  }
+
+  /**
+   * @param {string} - the input text to wrap
+   * @param [options] {object} - optional configuration
+   * @param [options.width] {number} - the max column width in characters (defaults to 30).
+   * @param [options.break] {boolean} - if true, words exceeding the specified `width` will be forcefully broken
+   * @param [options.noTrim] {boolean} - By default, each line output is trimmed. If `noTrim` is set, no line-trimming occurs - all whitespace from the input text is left in.
+   * @return {string}
+   */
+  static wrap (text, options) {
+    const block = new this(text, options)
+    return block.wrap()
+  }
+
+  /**
+   * Wraps the input text, returning an array of strings (lines).
+   * @param {string} - input text
+   * @param {object} - Accepts same options as constructor.
+   */
+  static lines (text, options) {
+    const block = new this(text, options)
+    return block.lines()
+  }
+
+  /**
+   * Returns true if the input text would be wrapped if passed into `.wrap()`.
+   * @param {string} - input text
+   * @return {boolean}
+   */
+  static isWrappable (text) {
+    if (t.isDefined(text)) {
+      text = String(text)
+      var matches = text.match(re.chunk)
+      return matches ? matches.length > 1 : false
+    }
+  }
+
+  /**
+   * Splits the input text into an array of words and whitespace.
+   * @param {string} - input text
+   * @returns {string[]}
+   */
+  static getChunks (text) {
+    return text.match(re.chunk) || []
+  }
+}
+
+function trimLine (line) {
+  return this.options.noTrim ? line : line.trim()
+}
+
+function replaceAnsi (string) {
+  return string.replace(re.ansiEscapeSequence, '')
+}
+
+/* break a word into several pieces */
+function breakWord (word) {
+  if (replaceAnsi(word).length > this.options.width) {
+    const letters = word.split('')
+    let piece
+    const pieces = []
+    while ((piece = letters.splice(0, this.options.width)).length) {
+      pieces.push(piece.join(''))
+    }
+    return pieces
+  } else {
+    return word
+  }
+}
+
+module.exports = WordWrap