columnify@1.4.1

columnify got es6ified!

1 files changed, 118 insertions, 95 deletions

diff --git a/node_modules/columnify/index.js b/node_modules/columnify/index.js
index 8c15c993e..781e683aa 100644
--- a/node_modules/columnify/index.js
+++ b/node_modules/columnify/index.js
@@ -1,23 +1,20 @@
 "use strict"
 
-var wcwidth = require('./width')
-var utils = require('./utils')
-var padRight = utils.padRight
-var padCenter = utils.padCenter
-var padLeft = utils.padLeft
-var splitIntoLines = utils.splitIntoLines
-var splitLongWords = utils.splitLongWords
-var truncateString = utils.truncateString
-
-var DEFAULT_HEADING_TRANSFORM = function(key) {
-  return key.toUpperCase()
-}
+const wcwidth = require('./width')
+const {
+  padRight,
+  padCenter,
+  padLeft,
+  splitIntoLines,
+  splitLongWords,
+  truncateString
+} = require('./utils')
 
-var DEFAULT_DATA_TRANSFORM = function(cell, column, index) {
-  return cell
-}
+const DEFAULT_HEADING_TRANSFORM = key => key.toUpperCase()
+
+const DEFAULT_DATA_TRANSFORM = (cell, column, index) => cell
 
-var DEFAULTS = {
+const DEFAULTS = Object.freeze({
   maxWidth: Infinity,
   minWidth: 0,
   columnSplitter: ' ',
@@ -28,50 +25,50 @@ var DEFAULTS = {
   showHeaders: true,
   headingTransform: DEFAULT_HEADING_TRANSFORM,
   dataTransform: DEFAULT_DATA_TRANSFORM
-}
-
-module.exports = function(items, options) {
+})
 
-  options = options || {}
+module.exports = function(items, options = {}) {
 
-  var columnConfigs = options.config || {}
+  let columnConfigs = options.config || {}
   delete options.config // remove config so doesn't appear on every column.
 
-  var maxLineWidth = options.maxLineWidth || Infinity
+  let maxLineWidth = options.maxLineWidth || Infinity
+  if (maxLineWidth === 'auto') maxLineWidth = process.stdout.columns || Infinity
   delete options.maxLineWidth // this is a line control option, don't pass it to column
 
   // Option defaults inheritance:
   // options.config[columnName] => options => DEFAULTS
-  options = mixin(options, DEFAULTS)
+  options = mixin({}, DEFAULTS, options)
+
   options.config = options.config || Object.create(null)
 
   options.spacing = options.spacing || '\n' // probably useless
   options.preserveNewLines = !!options.preserveNewLines
   options.showHeaders = !!options.showHeaders;
   options.columns = options.columns || options.include // alias include/columns, prefer columns if supplied
-  var columnNames = options.columns || [] // optional user-supplied columns to include
+  let columnNames = options.columns || [] // optional user-supplied columns to include
 
   items = toArray(items, columnNames)
 
   // if not suppled column names, automatically determine columns from data keys
   if (!columnNames.length) {
     items.forEach(function(item) {
-      for (var columnName in item) {
+      for (let columnName in item) {
         if (columnNames.indexOf(columnName) === -1) columnNames.push(columnName)
       }
     })
   }
 
   // initialize column defaults (each column inherits from options.config)
-  var columns = columnNames.reduce(function(columns, columnName) {
-    var column = Object.create(options)
+  let columns = columnNames.reduce((columns, columnName) => {
+    let column = Object.create(options)
     columns[columnName] = mixin(column, columnConfigs[columnName])
     return columns
   }, Object.create(null))
 
   // sanitize column settings
-  columnNames.forEach(function(columnName) {
-    var column = columns[columnName]
+  columnNames.forEach(columnName => {
+    let column = columns[columnName]
     column.name = columnName
     column.maxWidth = Math.ceil(column.maxWidth)
     column.minWidth = Math.ceil(column.minWidth)
@@ -80,9 +77,9 @@ module.exports = function(items, options) {
   })
 
   // sanitize data
-  items = items.map(function(item) {
-    var result = Object.create(null)
-    columnNames.forEach(function(columnName) {
+  items = items.map(item => {
+    let result = Object.create(null)
+    columnNames.forEach(columnName => {
       // null/undefined -> ''
       result[columnName] = item[columnName] != null ? item[columnName] : ''
       // toString everything
@@ -99,94 +96,92 @@ module.exports = function(items, options) {
   })
 
   // transform data cells
-  columnNames.forEach(function(columnName) {
-    var column = columns[columnName]
-    items = items.map(function(item, index) {
-      var col = Object.create(column)
+  columnNames.forEach(columnName => {
+    let column = columns[columnName]
+    items = items.map((item, index) => {
+      let col = Object.create(column)
       item[columnName] = column.dataTransform(item[columnName], col, index)
 
-      var changedKeys = Object.keys(col)
+      let changedKeys = Object.keys(col)
       // disable default heading transform if we wrote to column.name
       if (changedKeys.indexOf('name') !== -1) {
         if (column.headingTransform !== DEFAULT_HEADING_TRANSFORM) return
-        column.headingTransform = function(heading) {return heading}
+        column.headingTransform = heading => heading
       }
-      changedKeys.forEach(function(key) {
-        column[key] = col[key]
-      })
+      changedKeys.forEach(key => column[key] = col[key])
       return item
     })
   })
 
   // add headers
-  var headers = {}
+  let headers = {}
   if(options.showHeaders) {
-    columnNames.forEach(function(columnName) {
-      var column = columns[columnName]
+    columnNames.forEach(columnName => {
+      let column = columns[columnName]
       headers[columnName] = column.headingTransform(column.name)
     })
     items.unshift(headers)
   }
   // get actual max-width between min & max
   // based on length of data in columns
-  columnNames.forEach(function(columnName) {
-    var column = columns[columnName]
-    column.width = items.map(function(item) {
-      return item[columnName]
-    }).reduce(function(min, cur) {
+  columnNames.forEach(columnName => {
+    let column = columns[columnName]
+    column.width = items
+    .map(item => item[columnName])
+    .reduce((min, cur) => {
       return Math.max(min, Math.min(column.maxWidth, Math.max(column.minWidth, wcwidth(cur))))
     }, 0)
   })
 
   // split long words so they can break onto multiple lines
-  columnNames.forEach(function(columnName) {
-    var column = columns[columnName]
-    items = items.map(function(item) {
+  columnNames.forEach(columnName => {
+    let column = columns[columnName]
+    items = items.map(item => {
       item[columnName] = splitLongWords(item[columnName], column.width, column.truncateMarker)
       return item
     })
   })
 
   // wrap long lines. each item is now an array of lines.
-  columnNames.forEach(function(columnName) {
-    var column = columns[columnName]
-    items = items.map(function(item, index) {
-      var cell = item[columnName]
+  columnNames.forEach(columnName => {
+    let column = columns[columnName]
+    items = items.map((item, index) => {
+      let cell = item[columnName]
       item[columnName] = splitIntoLines(cell, column.width)
 
       // if truncating required, only include first line + add truncation char
       if (column.truncate && item[columnName].length > 1) {
-          item[columnName] = splitIntoLines(cell, column.width - wcwidth(column.truncateMarker))
-          var firstLine = item[columnName][0]
-          if (!endsWith(firstLine, column.truncateMarker)) item[columnName][0] += column.truncateMarker
-          item[columnName] = item[columnName].slice(0, 1)
+        item[columnName] = splitIntoLines(cell, column.width - wcwidth(column.truncateMarker))
+        let firstLine = item[columnName][0]
+        if (!endsWith(firstLine, column.truncateMarker)) item[columnName][0] += column.truncateMarker
+        item[columnName] = item[columnName].slice(0, 1)
       }
       return item
     })
   })
 
   // recalculate column widths from truncated output/lines
-  columnNames.forEach(function(columnName) {
-    var column = columns[columnName]
-    column.width = items.map(function(item) {
-      return item[columnName].reduce(function(min, cur) {
+  columnNames.forEach(columnName => {
+    let column = columns[columnName]
+    column.width = items.map(item => {
+      return item[columnName].reduce((min, cur) => {
         return Math.max(min, Math.min(column.maxWidth, Math.max(column.minWidth, wcwidth(cur))))
       }, 0)
-    }).reduce(function(min, cur) {
+    }).reduce((min, cur) => {
       return Math.max(min, Math.min(column.maxWidth, Math.max(column.minWidth, cur)))
     }, 0)
   })
 
 
-  var rows = createRows(items, columns, columnNames, options.paddingChr) // merge lines into rows
+  let rows = createRows(items, columns, columnNames, options.paddingChr) // merge lines into rows
   // conceive output
-  return rows.reduce(function(output, row) {
-    return output.concat(row.reduce(function(rowOut, line) {
+  return rows.reduce((output, row) => {
+    return output.concat(row.reduce((rowOut, line) => {
       return rowOut.concat(line.join(options.columnSplitter))
     }, []))
-  }, []).map(function(line) {
-    return truncateString(line, maxLineWidth)
-  }).join(options.spacing)
+  }, [])
+  .map(line => truncateString(line, maxLineWidth))
+  .join(options.spacing)
 }
 
 /**
@@ -199,18 +194,18 @@ module.exports = function(items, options) {
  */
 
 function createRows(items, columns, columnNames, paddingChr) {
-  return items.map(function(item) {
-    var row = []
-    var numLines = 0
-    columnNames.forEach(function(columnName) {
+  return items.map(item => {
+    let row = []
+    let numLines = 0
+    columnNames.forEach(columnName => {
       numLines = Math.max(numLines, item[columnName].length)
     })
     // combine matching lines of each rows
-    for (var i = 0; i < numLines; i++) {
+    for (let i = 0; i < numLines; i++) {
       row[i] = row[i] || []
-      columnNames.forEach(function(columnName) {
-        var column = columns[columnName]
-        var val = item[columnName][i] || '' // || '' ensures empty columns get padded
+      columnNames.forEach(columnName => {
+        let column = columns[columnName]
+        let val = item[columnName][i] || '' // || '' ensures empty columns get padded
         if (column.align === 'right') row[i].push(padLeft(val, column.width, paddingChr))
         else if (column.align === 'center' || column.align === 'centre') row[i].push(padCenter(val, column.width, paddingChr))
         else row[i].push(padRight(val, column.width, paddingChr))
@@ -221,22 +216,50 @@ function createRows(items, columns, columnNames, paddingChr) {
 }
 
 /**
- * Generic source->target mixin.
- * Copy properties from `source` into `target` if target doesn't have them.
- * Destructive. Modifies `target`.
+ * Object.assign
  *
- * @param target Object target for mixin properties.
- * @param source Object source of mixin properties.
- * @return Object `target` after mixin applied.
+ * @return Object Object with properties mixed in.
  */
 
-function mixin(target, source) {
-  source = source || {}
-  for (var key in source) {
-    if (target.hasOwnProperty(key)) continue
-    target[key] = source[key]
+function mixin(...args) {
+  if (Object.assign) return Object.assign(...args)
+  return ObjectAssign(...args)
+}
+
+function ObjectAssign(target, firstSource) {
+  "use strict";
+  if (target === undefined || target === null)
+    throw new TypeError("Cannot convert first argument to object");
+
+  var to = Object(target);
+
+  var hasPendingException = false;
+  var pendingException;
+
+  for (var i = 1; i < arguments.length; i++) {
+    var nextSource = arguments[i];
+    if (nextSource === undefined || nextSource === null)
+      continue;
+
+    var keysArray = Object.keys(Object(nextSource));
+    for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
+      var nextKey = keysArray[nextIndex];
+      try {
+        var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+        if (desc !== undefined && desc.enumerable)
+          to[nextKey] = nextSource[nextKey];
+      } catch (e) {
+        if (!hasPendingException) {
+          hasPendingException = true;
+          pendingException = e;
+        }
+      }
+    }
+
+    if (hasPendingException)
+      throw pendingException;
   }
-  return target
+  return to;
 }
 
 /**
@@ -246,16 +269,16 @@ function mixin(target, source) {
 function endsWith(target, searchString, position) {
   position = position || target.length;
   position = position - searchString.length;
-  var lastIndex = target.lastIndexOf(searchString);
+  let lastIndex = target.lastIndexOf(searchString);
   return lastIndex !== -1 && lastIndex === position;
 }
 
 
 function toArray(items, columnNames) {
   if (Array.isArray(items)) return items
-  var rows = []
-  for (var key in items) {
-    var item = {}
+  let rows = []
+  for (let key in items) {
+    let item = {}
     item[columnNames[0] || 'key'] = key
     item[columnNames[1] || 'value'] = items[key]
     rows.push(item)