tty-table 6.0.0 → 6.1.0

package/dist/cli.js

@@ -508,28 +508,28 @@ var import_wcwidth = __toESM(require_wcwidth());
 var addPadding = (config, width) => {
   return width + config.paddingLeft + config.paddingRight;
 };
+var getDisplayWidth = (value) => {
+  const lines = (0, import_strip_ansi2.default)(value.toString()).split(/[\n\r]/);
+  let widest = 0;
+  for (const line of lines) {
+    const width = (0, import_wcwidth.default)(line);
+    if (width > widest) widest = width;
+  }
+  return widest;
+};
 var getMaxLength = (columnOptions, rows, columnIndex) => {
-  let iterable;
+  let widest = 0;
   if (columnOptions && (columnOptions.value || columnOptions.alias)) {
-    let val = columnOptions.alias || columnOptions.value;
-    val = val.toString();
-    const headerRow = Array(rows[0].length);
-    headerRow[columnIndex] = val;
-    iterable = rows.slice();
-    iterable.push(headerRow);
-  } else {
-    iterable = rows;
+    const value = columnOptions.alias || columnOptions.value;
+    widest = getDisplayWidth(value);
   }
-  const widest = iterable.reduce((prev, row) => {
+  for (const row of rows) {
     if (row[columnIndex]) {
       const value = row[columnIndex].value ? row[columnIndex].value : row[columnIndex];
-      const width = Math.max(
-        ...(0, import_strip_ansi2.default)(value.toString()).split(/[\n\r]/).map((s) => (0, import_wcwidth.default)(s))
-      );
-      return width > prev ? width : prev;
+      const width = getDisplayWidth(value);
+      if (width > widest) widest = width;
     }
-    return prev;
-  }, 0);
+  }
   return widest;
 };
 var getAvailableWidth = (config) => {
@@ -594,13 +594,13 @@ var wrapCellText = (config, cellValue, columnIndex, cellOptions, rowType) => {
           emptySpace--;
           const padBoth = Math.floor(emptySpace / 2);
           const padRemainder = emptySpace % 2;
-          line = Array(padBoth + 1).join(" ") + line + Array(padBoth + 1 + padRemainder).join(" ");
+          line = " ".repeat(padBoth) + line + " ".repeat(padBoth + padRemainder);
           break;
         case cellOptions[alignTgt] === "right":
-          line = Array(emptySpace - cellOptions.paddingRight).join(" ") + line + Array(cellOptions.paddingRight + 1).join(" ");
+          line = " ".repeat(emptySpace - cellOptions.paddingRight - 1) + line + " ".repeat(cellOptions.paddingRight);
           break;
         default:
-          line = Array(cellOptions.paddingLeft + 1).join(" ") + line + Array(emptySpace - cellOptions.paddingLeft).join(" ");
+          line = " ".repeat(cellOptions.paddingLeft) + line + " ".repeat(emptySpace - cellOptions.paddingLeft - 1);
       }
     }
     return startMatches[0] + line + endMatches[0];
@@ -671,26 +671,18 @@ var getColumnWidths = (config, rows) => {
 // src/render.ts
 var import_strip_ansi3 = __toESM(require("strip-ansi"));
 var stringifyData = (config, inputData) => {
-  const sections = {
-    header: [],
-    body: [],
-    footer: []
-  };
-  const marginLeft = Array(config.marginLeft + 1).join(" ");
+  const sections = { header: [], body: [], footer: [] };
+  const marginLeft = " ".repeat(config.marginLeft);
   const borderStyle = config.borderCharacters[config.borderStyle];
   const borders = [];
   const constructorType = getConstructorGeometry(inputData[0] || [], config);
   const rows = coerceConstructorGeometry(config, inputData, constructorType);
-  if (!global.columnWidths) {
-    global.columnWidths = {};
-  }
+  if (!global.columnWidths) global.columnWidths = {};
   if (global.columnWidths[config.tableId]) {
     config.table.columnWidths = global.columnWidths[config.tableId];
   } else {
     const formattedRows = rows.map((row, rowIndex) => {
-      return row.map((cell, cellIndex) => {
-        return buildCell(config, cell, cellIndex, "body", rowIndex, rows, inputData, true);
-      });
+      return row.map((cell, cellIndex) => buildCell(config, cell, cellIndex, "body", rowIndex, rows, inputData, true));
     });
     global.columnWidths[config.tableId] = config.table.columnWidths = getColumnWidths(config, formattedRows);
   }
@@ -699,60 +691,49 @@ var stringifyData = (config, inputData) => {
       sections.header = [];
       break;
     case config.showHeader === true:
-    // explicitly true, show
     case !!config.table.header[0].find((obj) => obj.value || obj.alias):
-      sections.header = config.table.header.map((row) => {
-        return buildRow(config, row, "header", null, rows, inputData);
-      });
+      sections.header = config.table.header.map((row) => buildRow(config, row, "header", null, rows, inputData));
       break;
     default:
       sections.header = [];
   }
-  sections.body = rows.map((row, rowIndex) => {
-    return buildRow(config, row, "body", rowIndex, rows, inputData);
-  });
+  sections.body = rows.map((row, rowIndex) => buildRow(config, row, "body", rowIndex, rows, inputData));
   sections.footer = config.table.footer instanceof Array && config.table.footer.length > 0 ? [config.table.footer] : [];
-  sections.footer = sections.footer.map((row) => {
-    return buildRow(config, row, "footer", null, rows, inputData);
-  });
+  sections.footer = sections.footer.map((row) => buildRow(config, row, "footer", null, rows, inputData));
   for (let a = 0; a < 3; a++) {
     borders[a] = borderStyle[a].l;
     config.table.columnWidths.forEach((columnWidth, index, arr) => {
-      borders[a] += Array(Math.max(columnWidth, 2)).join(borderStyle[a].h);
+      borders[a] += borderStyle[a].h.repeat(Math.max(columnWidth, 2) - 1);
       borders[a] += index + 1 < arr.length ? borderStyle[a].j : "";
     });
     borders[a] += borderStyle[a].r;
     borders[a] = a < 2 ? `${marginLeft + borders[a]}
 ` : marginLeft + borders[a];
   }
-  let output = borders[0];
-  Object.keys(sections).forEach((p, i) => {
-    while (sections[p].length) {
-      const row = sections[p].shift();
+  const output = [borders[0]];
+  for (const [sectionIndex, sectionName] of Object.keys(sections).entries()) {
+    const section = sections[sectionName];
+    for (let rowIndex = 0; rowIndex < section.length; rowIndex++) {
+      const row = section[rowIndex];
       row.forEach((line) => {
-        output = `${output + marginLeft + borderStyle[1].v + line.join(borderStyle[1].v) + borderStyle[1].v}
-`;
+        output.push(marginLeft + borderStyle[1].v + line.join(borderStyle[1].v) + borderStyle[1].v + "\n");
       });
       switch (true) {
-        // skip if end of body and no footer
-        case (sections[p].length === 0 && i === 1 && sections.footer.length === 0):
+        case (rowIndex === section.length - 1 && sectionIndex === 1 && sections.footer.length === 0):
           break;
-        // skip if end of footer
-        case (sections[p].length === 0 && i === 2):
+        case (rowIndex === section.length - 1 && sectionIndex === 2):
           break;
-        // skip if compact
-        case (config.compact && p === "body" && !row.empty):
+        case (config.compact && sectionName === "body" && !row.empty):
           break;
-        // skip if border style is "none"
         case (config.borderStyle === "none" && config.compact):
           break;
         default:
-          output += borders[1];
+          output.push(borders[1]);
       }
     }
-  });
-  output += borders[2];
-  const finalOutput = Array(config.marginTop + 1).join("\n") + output;
+  }
+  output.push(borders[2]);
+  const finalOutput = "\n".repeat(config.marginTop) + output.join("");
   config.height = finalOutput.split(/\r\n|\r|\n/).length;
   return finalOutput;
 };
@@ -763,11 +744,8 @@ var buildRow = (config, row, rowType, rowIndex, rowData, inputData) => {
     return row;
   }
   const lengthDifference = config.table.columnWidths.length - row.length;
-  if (lengthDifference > 0) {
-    row = row.concat(Array.apply(null, new Array(lengthDifference)).map(() => null));
-  } else if (lengthDifference < 0) {
-    row.length = config.table.columnWidths.length;
-  }
+  if (lengthDifference > 0) row = row.concat(Array.apply(null, new Array(lengthDifference)).map(() => null));
+  else if (lengthDifference < 0) row.length = config.table.columnWidths.length;
   row = row.map((elem, elemIndex) => {
     const cell = buildCell(config, elem, elemIndex, rowType, rowIndex, rowData, inputData);
     minRowHeight = minRowHeight < cell.length ? cell.length : minRowHeight;
@@ -776,18 +754,12 @@ var buildRow = (config, row, rowType, rowIndex, rowData, inputData) => {
   minRowHeight = rowType === "header" ? minRowHeight : minRowHeight + (config.paddingBottom + config.paddingTop);
   const linedRow = Array.apply(null, { length: minRowHeight }).map(Function.call, () => []);
   row.forEach(function(cell, a) {
-    const whitespace = Array(config.table.columnWidths[a]).join(" ");
+    const whitespace = " ".repeat(Math.max(config.table.columnWidths[a] - 1, 0));
     if (rowType === "body") {
-      for (let i = 0; i < config.paddingTop; i++) {
-        cell.unshift(whitespace);
-      }
-      for (let i = 0; i < config.paddingBottom; i++) {
-        cell.push(whitespace);
-      }
-    }
-    for (let i = 0; i < minRowHeight; i++) {
-      linedRow[i].push(typeof cell[i] !== "undefined" ? cell[i] : whitespace);
+      for (let i = 0; i < config.paddingTop; i++) cell.unshift(whitespace);
+      for (let i = 0; i < config.paddingBottom; i++) cell.push(whitespace);
     }
+    for (let i = 0; i < minRowHeight; i++) linedRow[i].push(typeof cell[i] !== "undefined" ? cell[i] : whitespace);
   });
   return linedRow;
 };
@@ -806,9 +778,7 @@ var buildCell = (config, elem, columnIndex, rowType, rowIndex, rowData, inputDat
     switch (true) {
       case (typeof elem === "undefined" || elem === null):
         cellValue = config.errorOnNull ? config.defaultErrorValue : config.defaultValue;
-        if (!isColorEnabled()) {
-          cellValue = (0, import_strip_ansi3.default)(cellValue);
-        }
+        if (!isColorEnabled()) cellValue = (0, import_strip_ansi3.default)(cellValue);
         cellOptions.isNull = true;
         break;
       case (typeof elem === "object" && elem !== null && typeof elem.value !== "undefined"):
@@ -821,13 +791,7 @@ var buildCell = (config, elem, columnIndex, rowType, rowIndex, rowData, inputDat
           },
           style,
           resetStyle
-        })(
-          cellValue,
-          columnIndex,
-          rowIndex,
-          rowData,
-          inputData
-        );
+        })(cellValue, columnIndex, rowIndex, rowData, inputData);
         break;
       default:
         cellValue = elem;
@@ -839,25 +803,13 @@ var buildCell = (config, elem, columnIndex, rowType, rowIndex, rowData, inputDat
         },
         style,
         resetStyle
-      })(
-        cellValue,
-        columnIndex,
-        rowIndex,
-        rowData,
-        inputData
-      );
+      })(cellValue, columnIndex, rowIndex, rowData, inputData);
     }
-    if (dryRun) {
-      return cellValue;
-    }
-  }
-  if (!cellOptions.reset) {
-    cellValue = colorizeCell(cellValue, cellOptions, rowType);
+    if (dryRun) return cellValue;
   }
+  if (!cellOptions.reset) cellValue = colorizeCell(cellValue, cellOptions, rowType);
   const { cell, innerWidth } = wrapCellText(cellOptions, cellValue, columnIndex, cellOptions, rowType);
-  if (rowType === "header") {
-    config.table.columnInnerWidths.push(innerWidth);
-  }
+  if (rowType === "header") config.table.columnInnerWidths.push(innerWidth);
   return cell;
 };
 var getConstructorGeometry = (row, config) => {
@@ -866,17 +818,9 @@ var getConstructorGeometry = (row, config) => {
     const keys = Object.keys(row);
     if (config.adapter === "automattic") {
       const key = keys[0];
-      if (row[key] instanceof Array) {
-        type = "automattic-cross";
-      } else {
-        type = "automattic-vertical";
-      }
-    } else {
-      type = "o-horizontal";
-    }
-  } else {
-    type = "a-horizontal";
-  }
+      type = row[key] instanceof Array ? "automattic-cross" : "automattic-vertical";
+    } else type = "o-horizontal";
+  } else type = "a-horizontal";
   return type;
 };
 var coerceConstructorGeometry = (config, rows, constructorType) => {
@@ -886,16 +830,14 @@ var coerceConstructorGeometry = (config, rows, constructorType) => {
       config.columnSettings[0] = config.columnSettings[0] || {};
       config.columnSettings[0].color = config.headerColor;
       output = rows.map((obj) => {
-        const arr = [];
         const key = Object.keys(obj)[0];
-        arr.push(key);
-        return arr.concat(obj[key]);
+        return [key].concat(obj[key]);
       });
       break;
     case "automattic-vertical":
       config.columnSettings[0] = config.columnSettings[0] || {};
       config.columnSettings[0].color = config.headerColor;
-      output = rows.map(function(value) {
+      output = rows.map((value) => {
         const key = Object.keys(value)[0];
         return [key, value[key]];
       });
@@ -903,14 +845,11 @@ var coerceConstructorGeometry = (config, rows, constructorType) => {
     case "o-horizontal":
       if (config.table.header[0].length && config.table.header[0].every((obj) => obj.value)) {
         output = rows.map((row) => config.table.header[0].map((obj) => row[obj.value]));
-      } else {
-        output = rows.map((obj) => Object.values(obj));
-      }
+      } else output = rows.map((obj) => Object.values(obj));
       break;
     case "a-horizontal":
       output = rows;
       break;
-    default:
   }
   return output;
 };