"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/columnify/columnify.js" (7 Feb 2017, 10180 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 "use strict";
    2 
    3 var wcwidth = require('./width');
    4 
    5 var _require = require('./utils');
    6 
    7 var padRight = _require.padRight;
    8 var padCenter = _require.padCenter;
    9 var padLeft = _require.padLeft;
   10 var splitIntoLines = _require.splitIntoLines;
   11 var splitLongWords = _require.splitLongWords;
   12 var truncateString = _require.truncateString;
   13 
   14 var DEFAULT_HEADING_TRANSFORM = function DEFAULT_HEADING_TRANSFORM(key) {
   15   return key.toUpperCase();
   16 };
   17 
   18 var DEFAULT_DATA_TRANSFORM = function DEFAULT_DATA_TRANSFORM(cell, column, index) {
   19   return cell;
   20 };
   21 
   22 var DEFAULTS = Object.freeze({
   23   maxWidth: Infinity,
   24   minWidth: 0,
   25   columnSplitter: ' ',
   26   truncate: false,
   27   truncateMarker: '…',
   28   preserveNewLines: false,
   29   paddingChr: ' ',
   30   showHeaders: true,
   31   headingTransform: DEFAULT_HEADING_TRANSFORM,
   32   dataTransform: DEFAULT_DATA_TRANSFORM
   33 });
   34 
   35 module.exports = function (items) {
   36   var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
   37 
   38   var columnConfigs = options.config || {};
   39   delete options.config; // remove config so doesn't appear on every column.
   40 
   41   var maxLineWidth = options.maxLineWidth || Infinity;
   42   if (maxLineWidth === 'auto') maxLineWidth = process.stdout.columns || Infinity;
   43   delete options.maxLineWidth; // this is a line control option, don't pass it to column
   44 
   45   // Option defaults inheritance:
   46   // options.config[columnName] => options => DEFAULTS
   47   options = mixin({}, DEFAULTS, options);
   48 
   49   options.config = options.config || Object.create(null);
   50 
   51   options.spacing = options.spacing || '\n'; // probably useless
   52   options.preserveNewLines = !!options.preserveNewLines;
   53   options.showHeaders = !!options.showHeaders;
   54   options.columns = options.columns || options.include; // alias include/columns, prefer columns if supplied
   55   var columnNames = options.columns || []; // optional user-supplied columns to include
   56 
   57   items = toArray(items, columnNames);
   58 
   59   // if not suppled column names, automatically determine columns from data keys
   60   if (!columnNames.length) {
   61     items.forEach(function (item) {
   62       for (var columnName in item) {
   63         if (columnNames.indexOf(columnName) === -1) columnNames.push(columnName);
   64       }
   65     });
   66   }
   67 
   68   // initialize column defaults (each column inherits from options.config)
   69   var columns = columnNames.reduce(function (columns, columnName) {
   70     var column = Object.create(options);
   71     columns[columnName] = mixin(column, columnConfigs[columnName]);
   72     return columns;
   73   }, Object.create(null));
   74 
   75   // sanitize column settings
   76   columnNames.forEach(function (columnName) {
   77     var column = columns[columnName];
   78     column.name = columnName;
   79     column.maxWidth = Math.ceil(column.maxWidth);
   80     column.minWidth = Math.ceil(column.minWidth);
   81     column.truncate = !!column.truncate;
   82     column.align = column.align || 'left';
   83   });
   84 
   85   // sanitize data
   86   items = items.map(function (item) {
   87     var result = Object.create(null);
   88     columnNames.forEach(function (columnName) {
   89       // null/undefined -> ''
   90       result[columnName] = item[columnName] != null ? item[columnName] : '';
   91       // toString everything
   92       result[columnName] = '' + result[columnName];
   93       if (columns[columnName].preserveNewLines) {
   94         // merge non-newline whitespace chars
   95         result[columnName] = result[columnName].replace(/[^\S\n]/gmi, ' ');
   96       } else {
   97         // merge all whitespace chars
   98         result[columnName] = result[columnName].replace(/\s/gmi, ' ');
   99       }
  100     });
  101     return result;
  102   });
  103 
  104   // transform data cells
  105   columnNames.forEach(function (columnName) {
  106     var column = columns[columnName];
  107     items = items.map(function (item, index) {
  108       var col = Object.create(column);
  109       item[columnName] = column.dataTransform(item[columnName], col, index);
  110 
  111       var changedKeys = Object.keys(col);
  112       // disable default heading transform if we wrote to column.name
  113       if (changedKeys.indexOf('name') !== -1) {
  114         if (column.headingTransform !== DEFAULT_HEADING_TRANSFORM) return;
  115         column.headingTransform = function (heading) {
  116           return heading;
  117         };
  118       }
  119       changedKeys.forEach(function (key) {
  120         return column[key] = col[key];
  121       });
  122       return item;
  123     });
  124   });
  125 
  126   // add headers
  127   var headers = {};
  128   if (options.showHeaders) {
  129     columnNames.forEach(function (columnName) {
  130       var column = columns[columnName];
  131 
  132       if (!column.showHeaders) {
  133         headers[columnName] = '';
  134         return;
  135       }
  136 
  137       headers[columnName] = column.headingTransform(column.name);
  138     });
  139     items.unshift(headers);
  140   }
  141   // get actual max-width between min & max
  142   // based on length of data in columns
  143   columnNames.forEach(function (columnName) {
  144     var column = columns[columnName];
  145     column.width = items.map(function (item) {
  146       return item[columnName];
  147     }).reduce(function (min, cur) {
  148       // if already at maxWidth don't bother testing
  149       if (min >= column.maxWidth) return min;
  150       return Math.max(min, Math.min(column.maxWidth, Math.max(column.minWidth, wcwidth(cur))));
  151     }, 0);
  152   });
  153 
  154   // split long words so they can break onto multiple lines
  155   columnNames.forEach(function (columnName) {
  156     var column = columns[columnName];
  157     items = items.map(function (item) {
  158       item[columnName] = splitLongWords(item[columnName], column.width, column.truncateMarker);
  159       return item;
  160     });
  161   });
  162 
  163   // wrap long lines. each item is now an array of lines.
  164   columnNames.forEach(function (columnName) {
  165     var column = columns[columnName];
  166     items = items.map(function (item, index) {
  167       var cell = item[columnName];
  168       item[columnName] = splitIntoLines(cell, column.width);
  169 
  170       // if truncating required, only include first line + add truncation char
  171       if (column.truncate && item[columnName].length > 1) {
  172         item[columnName] = splitIntoLines(cell, column.width - wcwidth(column.truncateMarker));
  173         var firstLine = item[columnName][0];
  174         if (!endsWith(firstLine, column.truncateMarker)) item[columnName][0] += column.truncateMarker;
  175         item[columnName] = item[columnName].slice(0, 1);
  176       }
  177       return item;
  178     });
  179   });
  180 
  181   // recalculate column widths from truncated output/lines
  182   columnNames.forEach(function (columnName) {
  183     var column = columns[columnName];
  184     column.width = items.map(function (item) {
  185       return item[columnName].reduce(function (min, cur) {
  186         if (min >= column.maxWidth) return min;
  187         return Math.max(min, Math.min(column.maxWidth, Math.max(column.minWidth, wcwidth(cur))));
  188       }, 0);
  189     }).reduce(function (min, cur) {
  190       if (min >= column.maxWidth) return min;
  191       return Math.max(min, Math.min(column.maxWidth, Math.max(column.minWidth, cur)));
  192     }, 0);
  193   });
  194 
  195   var rows = createRows(items, columns, columnNames, options.paddingChr); // merge lines into rows
  196   // conceive output
  197   return rows.reduce(function (output, row) {
  198     return output.concat(row.reduce(function (rowOut, line) {
  199       return rowOut.concat(line.join(options.columnSplitter));
  200     }, []));
  201   }, []).map(function (line) {
  202     return truncateString(line, maxLineWidth);
  203   }).join(options.spacing);
  204 };
  205 
  206 /**
  207  * Convert wrapped lines into rows with padded values.
  208  *
  209  * @param Array items data to process
  210  * @param Array columns column width settings for wrapping
  211  * @param Array columnNames column ordering
  212  * @return Array items wrapped in arrays, corresponding to lines
  213  */
  214 
  215 function createRows(items, columns, columnNames, paddingChr) {
  216   return items.map(function (item) {
  217     var row = [];
  218     var numLines = 0;
  219     columnNames.forEach(function (columnName) {
  220       numLines = Math.max(numLines, item[columnName].length);
  221     });
  222     // combine matching lines of each rows
  223 
  224     var _loop = function _loop(i) {
  225       row[i] = row[i] || [];
  226       columnNames.forEach(function (columnName) {
  227         var column = columns[columnName];
  228         var val = item[columnName][i] || ''; // || '' ensures empty columns get padded
  229         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));
  230       });
  231     };
  232 
  233     for (var i = 0; i < numLines; i++) {
  234       _loop(i);
  235     }
  236     return row;
  237   });
  238 }
  239 
  240 /**
  241  * Object.assign
  242  *
  243  * @return Object Object with properties mixed in.
  244  */
  245 
  246 function mixin() {
  247   var _Object;
  248 
  249   if (Object.assign) return (_Object = Object).assign.apply(_Object, arguments);
  250   return ObjectAssign.apply(undefined, arguments);
  251 }
  252 
  253 function ObjectAssign(target, firstSource) {
  254   "use strict";
  255 
  256   if (target === undefined || target === null) throw new TypeError("Cannot convert first argument to object");
  257 
  258   var to = Object(target);
  259 
  260   var hasPendingException = false;
  261   var pendingException;
  262 
  263   for (var i = 1; i < arguments.length; i++) {
  264     var nextSource = arguments[i];
  265     if (nextSource === undefined || nextSource === null) continue;
  266 
  267     var keysArray = Object.keys(Object(nextSource));
  268     for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
  269       var nextKey = keysArray[nextIndex];
  270       try {
  271         var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
  272         if (desc !== undefined && desc.enumerable) to[nextKey] = nextSource[nextKey];
  273       } catch (e) {
  274         if (!hasPendingException) {
  275           hasPendingException = true;
  276           pendingException = e;
  277         }
  278       }
  279     }
  280 
  281     if (hasPendingException) throw pendingException;
  282   }
  283   return to;
  284 }
  285 
  286 /**
  287  * Adapted from String.prototype.endsWith polyfill.
  288  */
  289 
  290 function endsWith(target, searchString, position) {
  291   position = position || target.length;
  292   position = position - searchString.length;
  293   var lastIndex = target.lastIndexOf(searchString);
  294   return lastIndex !== -1 && lastIndex === position;
  295 }
  296 
  297 function toArray(items, columnNames) {
  298   if (Array.isArray(items)) return items;
  299   var rows = [];
  300   for (var key in items) {
  301     var item = {};
  302     item[columnNames[0] || 'key'] = key;
  303     item[columnNames[1] || 'value'] = items[key];
  304     rows.push(item);
  305   }
  306   return rows;
  307 }
  308