Finish feature

Author: nhle-mgmtp

package.json

@@ -37,15 +37,13 @@
     "semantic-release": "^17.3.1",
     "sinon": "^9.2.2",
     "ts-node": "^9.1.1",
-    "typescript": "4.2.4"
+    "typescript": "4.4.4"
   },
   "engines": {
     "node": ">=10.0.0"
   },
   "husky": {
     "hooks": {
-      "post-commit": "npm run create-readme && git add README.md && git commit -m 'docs: generate docs' --no-verify",
-      "pre-commit": "npm run build && npm run lint && npm run test"
     }
   },
   "keywords": [

src/alignCellSpanning.ts

@@ -0,0 +1,62 @@
+import {
+  alignString,
+} from './alignString';
+import {
+  padCellVertically,
+} from './mapDataUsingRowHeights';
+import {
+  padString,
+} from './padTableData';
+import type {
+  SpanningCellContext,
+} from './spanningCellManager';
+import {
+  truncateString,
+} from './truncateTableData';
+import type {
+  RangeConfig,
+} from './types/internal';
+import {
+  sequence, sumArray,
+} from './utils';
+import {
+  wrapCell,
+} from './wrapCell';
+
+export const wrapContentRange = (rangeConfig: RangeConfig, rangeWidth: number, context: SpanningCellContext): string[] => {
+  const {topLeft, paddingRight, paddingLeft, truncate, wrapWord, alignment} = rangeConfig;
+
+  const originalContent = context.rows[topLeft.row][topLeft.col];
+  const contentWidth = rangeWidth - paddingLeft - paddingRight;
+
+  return wrapCell(truncateString(originalContent, truncate), contentWidth, wrapWord).map((line) => {
+    const alignedLine = alignString(line, contentWidth, alignment);
+
+    return padString(alignedLine, paddingLeft, paddingRight);
+  });
+};
+
+export const alignVerticalContentRange = (range: RangeConfig, content: string[], context: SpanningCellContext) => {
+  const {rows, drawHorizontalLine, rowHeights} = context;
+  const {topLeft, bottomRight, verticalAlignment} = range;
+
+  if (rowHeights.length === 0) {
+    return [];
+  }
+
+  const totalCellHeight = sumArray(rowHeights.slice(topLeft.row, bottomRight.row + 1));
+  const totalBorderHeight = bottomRight.row - topLeft.row;
+  const hiddenHorizontalBorderCount = sequence(topLeft.row + 1, bottomRight.row).filter((horizontalBorderIndex) => {
+    return !drawHorizontalLine(horizontalBorderIndex, rows.length);
+  }).length;
+
+  const availableRangeHeight = totalCellHeight + totalBorderHeight - hiddenHorizontalBorderCount;
+
+  return padCellVertically(content, availableRangeHeight, verticalAlignment).map((line) => {
+    if (line.length === 0) {
+      return ' '.repeat(content[0].length);
+    }
+
+    return line;
+  });
+};

src/alignTableData.ts

@@ -7,10 +7,16 @@ import type {
 } from './types/internal';
 
 export const alignTableData = (rows: Row[], config: BaseConfig): Row[] => {
-  return rows.map((row) => {
+  return rows.map((row, rowIndex) => {
     return row.map((cell, cellIndex) => {
       const {width, alignment} = config.columns[cellIndex];
 
+      const containingRange = config.spanningCellManager?.getContainingRange({col: cellIndex,
+        row: rowIndex}, {mapped: true});
+      if (containingRange) {
+        return cell;
+      }
+
       return alignString(cell, width, alignment);
     });
   });

src/calculatCellSpanningWidth.ts

@@ -0,0 +1,39 @@
+import type {
+  SpanningCellParameters,
+} from './spanningCellManager';
+import type {
+  RangeConfig,
+} from './types/internal';
+import {
+  sequence, sumArray,
+} from './utils';
+
+export const calculateCellSpanningWidth = (range: RangeConfig, dependencies: SpanningCellParameters): number => {
+  const {columnsConfig, drawVerticalLine} = dependencies;
+  const {topLeft, bottomRight} = range;
+
+  const totalWidth = sumArray(
+    columnsConfig.slice(topLeft.col, bottomRight.col + 1).map(({width}) => {
+      return width;
+    }),
+  );
+
+  const totalPadding =
+    topLeft.col === bottomRight.col ?
+      columnsConfig[topLeft.col].paddingRight +
+      columnsConfig[bottomRight.col].paddingLeft :
+      sumArray(
+        columnsConfig
+          .slice(topLeft.col, bottomRight.col + 1)
+          .map(({paddingLeft, paddingRight}) => {
+            return paddingLeft + paddingRight;
+          }),
+      );
+  const totalBorderWidths = bottomRight.col - topLeft.col;
+
+  const totalHiddenVerticalBorders = sequence(topLeft.col + 1, bottomRight.col).filter((verticalBorderIndex) => {
+    return !drawVerticalLine(verticalBorderIndex, columnsConfig.length);
+  }).length;
+
+  return totalWidth + totalPadding + totalBorderWidths - totalHiddenVerticalBorders;
+};

src/calculateCellWidths.ts

@@ -0,0 +1,42 @@
+import stringWidth from 'string-width';
+import type {
+  SpanningCellConfig,
+} from './types/api';
+import type {
+  Row,
+  Cell,
+} from './types/internal';
+import {
+  calculateRangeCoordinate, isCellInRange,
+} from './utils';
+
+export const calculateMaximumCellWidth = (cell: Cell): number => {
+  return Math.max(
+    ...cell.split('\n').map(stringWidth),
+  );
+};
+
+/**
+ * Produces an array of values that describe the largest value length (width) in every column.
+ */
+export const calculateMaximumColumnWidths = (rows: Row[], cellSpanningConfigs: SpanningCellConfig[] = []): number[] => {
+  const columnWidths = new Array(rows[0].length).fill(0);
+  const rangeCoordinates = cellSpanningConfigs.map(calculateRangeCoordinate);
+  const isCellSpanning = (rowIndex: number, columnIndex: number): boolean => {
+    return rangeCoordinates.some((rangeCoordinate) => {
+      return isCellInRange({col: columnIndex,
+        row: rowIndex}, rangeCoordinate);
+    });
+  };
+
+  rows.forEach((row, rowIndex) => {
+    row.forEach((cell, cellIndex) => {
+      if (isCellSpanning(rowIndex, cellIndex)) {
+        return;
+      }
+      columnWidths[cellIndex] = Math.max(columnWidths[cellIndex], calculateMaximumCellWidth(cell));
+    });
+  });
+
+  return columnWidths;
+};

src/calculateColumnWidths.ts

@@ -0,0 +1,9 @@
+import type {
+  TableConfig,
+} from './types/internal';
+
+export const calculateOutputColumnWidths = (config: TableConfig): number[] => {
+  return config.columns.map((col) => {
+    return col.paddingLeft + col.width + col.paddingRight;
+  });
+};

src/calculateMaximumColumnWidths.ts

@@ -5,20 +5,49 @@ import type {
   BaseConfig,
   Row,
 } from './types/internal';
+import {
+  sequence,
+  sumArray,
+} from './utils';
 
 /**
  * Produces an array of values that describe the largest value length (height) in every row.
  */
 export const calculateRowHeights = (rows: Row[], config: BaseConfig): number[] => {
-  return rows.map((row) => {
+  const rowHeights: number[] = [];
+
+  for (const [rowIndex, row] of rows.entries()) {
     let rowHeight = 1;
 
     row.forEach((cell, cellIndex) => {
-      const cellHeight = calculateCellHeight(cell, config.columns[cellIndex].width, config.columns[cellIndex].wrapWord);
+      const containingRange = config.spanningCellManager?.getContainingRange({col: cellIndex,
+        row: rowIndex});
+
+      if (!containingRange) {
+        const cellHeight = calculateCellHeight(cell, config.columns[cellIndex].width, config.columns[cellIndex].wrapWord);
+        rowHeight = Math.max(rowHeight, cellHeight);
+
+        return;
+      }
+      const {topLeft, bottomRight, height} = containingRange;
 
-      rowHeight = Math.max(rowHeight, cellHeight);
+      // bottom-most cell of a range needs to contain all remain lines of spanning cells
+      if (rowIndex === bottomRight.row) {
+        const totalOccupiedSpanningCellHeight = sumArray(rowHeights.slice(topLeft.row));
+        const totalHorizontalBorderHeight = bottomRight.row - topLeft.row;
+        const totalHiddenHorizontalBorderHeight = sequence(topLeft.row + 1, bottomRight.row).filter((horizontalBorderIndex) => {
+          return !config.drawHorizontalLine?.(horizontalBorderIndex, rows.length);
+        }).length;
+
+        const cellHeight = height - totalOccupiedSpanningCellHeight - totalHorizontalBorderHeight + totalHiddenHorizontalBorderHeight;
+        rowHeight = Math.max(rowHeight, cellHeight);
+      }
+
+      // otherwise, just depend on other sibling cell heights in the row
     });
 
-    return rowHeight;
-  });
+    rowHeights.push(rowHeight);
+  }
+
+  return rowHeights;
 };

src/calculateOutputColumnWidths.ts

@@ -34,11 +34,14 @@ import type {
 import type {
   Row, StreamConfig,
 } from './types/internal';
+import {
+  extractTruncates,
+} from './utils';
 
 const prepareData = (data: Row[], config: StreamConfig) => {
   let rows = stringifyTableData(data);
 
-  rows = truncateTableData(rows, config);
+  rows = truncateTableData(rows, extractTruncates(config));
 
   const rowHeights = calculateRowHeights(rows, config);