table 6.5.1 → 6.7.2

package/dist/alignString.d.ts

@@ -1,7 +1,6 @@
-import type { ColumnUserConfig } from './types/api';
-declare const _default: (subject: string, containerWidth: number, alignment: ColumnUserConfig['alignment']) => string;
+import type { Alignment } from './types/api';
 /**
  * Pads a string to the left and/or right to position the subject
  * text in a desired alignment within a container.
  */
-export default _default;
+export declare const alignString: (subject: string, containerWidth: number, alignment: Alignment) => string;

package/dist/alignString.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignString = void 0;
 const string_width_1 = __importDefault(require("string-width"));
+const utils_1 = require("./utils");
 const alignLeft = (subject, width) => {
     return subject + ' '.repeat(width);
 };
@@ -11,25 +13,31 @@ const alignRight = (subject, width) => {
     return ' '.repeat(width) + subject;
 };
 const alignCenter = (subject, width) => {
-    let halfWidth;
-    halfWidth = width / 2;
-    if (width % 2 === 0) {
-        return ' '.repeat(halfWidth) + subject + ' '.repeat(halfWidth);
+    return ' '.repeat(Math.floor(width / 2)) + subject + ' '.repeat(Math.ceil(width / 2));
+};
+const alignJustify = (subject, width) => {
+    const spaceSequenceCount = utils_1.countSpaceSequence(subject);
+    if (spaceSequenceCount === 0) {
+        return alignLeft(subject, width);
     }
-    else {
-        halfWidth = Math.floor(halfWidth);
-        return ' '.repeat(halfWidth) + subject + ' '.repeat(halfWidth + 1);
+    const addingSpaces = utils_1.distributeUnevenly(width, spaceSequenceCount);
+    if (Math.max(...addingSpaces) > 3) {
+        return alignLeft(subject, width);
     }
+    let spaceSequenceIndex = 0;
+    return subject.replace(/\s+/g, (groupSpace) => {
+        return groupSpace + ' '.repeat(addingSpaces[spaceSequenceIndex++]);
+    });
 };
 /**
  * Pads a string to the left and/or right to position the subject
  * text in a desired alignment within a container.
  */
-exports.default = (subject, containerWidth, alignment) => {
-    if (typeof subject !== 'string') {
-        throw new TypeError('Subject parameter value must be a string.');
-    }
+const alignString = (subject, containerWidth, alignment) => {
     const subjectWidth = string_width_1.default(subject);
+    if (subjectWidth === containerWidth) {
+        return subject;
+    }
     if (subjectWidth > containerWidth) {
         throw new Error('Subject parameter value width cannot be greater than the container width.');
     }
@@ -43,5 +51,9 @@ exports.default = (subject, containerWidth, alignment) => {
     if (alignment === 'right') {
         return alignRight(subject, availableWidth);
     }
+    if (alignment === 'justify') {
+        return alignJustify(subject, availableWidth);
+    }
     return alignCenter(subject, availableWidth);
 };
+exports.alignString = alignString;

package/dist/alignTableData.d.ts

@@ -1,3 +1,2 @@
 import type { BaseConfig, Row } from './types/internal';
-declare const _default: (rows: Row[], config: BaseConfig) => Row[];
-export default _default;
+export declare const alignTableData: (rows: Row[], config: BaseConfig) => Row[];

package/dist/alignTableData.js

@@ -1,20 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const string_width_1 = __importDefault(require("string-width"));
-const alignString_1 = __importDefault(require("./alignString"));
-exports.default = (rows, config) => {
+exports.alignTableData = void 0;
+const alignString_1 = require("./alignString");
+const alignTableData = (rows, config) => {
     return rows.map((row) => {
-        return row.map((cell, index) => {
-            const column = config.columns[index];
-            if (string_width_1.default(cell) === column.width) {
-                return cell;
-            }
-            else {
-                return alignString_1.default(cell, column.width, column.alignment);
-            }
+        return row.map((cell, cellIndex) => {
+            const { width, alignment } = config.columns[cellIndex];
+            return alignString_1.alignString(cell, width, alignment);
         });
     });
 };
+exports.alignTableData = alignTableData;

package/dist/calculateCellHeight.d.ts

@@ -1,2 +1,4 @@
-declare const _default: (value: string, columnWidth: number, useWrapWord?: boolean) => number;
-export default _default;
+/**
+ * Calculates height of cell content in regard to its width and word wrapping.
+ */
+export declare const calculateCellHeight: (value: string, columnWidth: number, useWrapWord?: boolean) => number;

package/dist/calculateCellHeight.js

@@ -1,12 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const wrapCell_1 = __importDefault(require("./wrapCell"));
-exports.default = (value, columnWidth, useWrapWord = false) => {
-    if (typeof value !== 'string') {
-        throw new TypeError('Value must be a string.');
-    }
-    return wrapCell_1.default(value, columnWidth, useWrapWord).length;
+exports.calculateCellHeight = void 0;
+const wrapCell_1 = require("./wrapCell");
+/**
+ * Calculates height of cell content in regard to its width and word wrapping.
+ */
+const calculateCellHeight = (value, columnWidth, useWrapWord = false) => {
+    return wrapCell_1.wrapCell(value, columnWidth, useWrapWord).length;
 };
+exports.calculateCellHeight = calculateCellHeight;

package/dist/calculateCellWidths.d.ts

@@ -0,0 +1,5 @@
+import type { Cell } from './types/internal';
+/**
+ * Calculates width of each cell contents in a row.
+ */
+export declare const calculateCellWidths: (cells: Cell[]) => number[];

package/dist/{calculateCellWidthIndex.js → calculateCellWidths.js}

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCellWidths = void 0;
 const string_width_1 = __importDefault(require("string-width"));
 /**
- * Calculates width of each cell contents.
+ * Calculates width of each cell contents in a row.
  */
-exports.default = (cells) => {
-    return cells.map((value) => {
-        return Math.max(...value.split('\n').map((line) => {
-            return string_width_1.default(line);
-        }));
+const calculateCellWidths = (cells) => {
+    return cells.map((cell) => {
+        return Math.max(...cell.split('\n').map(string_width_1.default));
     });
 };
+exports.calculateCellWidths = calculateCellWidths;

package/dist/calculateColumnWidths.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const calculateCellWidths_1 = require("./calculateCellWidths");
+/**
+ * Produces an array of values that describe the largest value length (width) in every column.
+ */
+exports.default = (rows) => {
+    const columnWidths = new Array(rows[0].length).fill(0);
+    rows.forEach((row) => {
+        const cellWidths = calculateCellWidths_1.calculateCellWidths(row);
+        cellWidths.forEach((cellWidth, cellIndex) => {
+            columnWidths[cellIndex] = Math.max(columnWidths[cellIndex], cellWidth);
+        });
+    });
+    return columnWidths;
+};

package/dist/calculateRowHeights.d.ts

@@ -0,0 +1,5 @@
+import type { BaseConfig, Row } from './types/internal';
+/**
+ * Produces an array of values that describe the largest value length (height) in every row.
+ */
+export declare const calculateRowHeights: (rows: Row[], config: BaseConfig) => number[];

package/dist/calculateRowHeights.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRowHeights = void 0;
+const calculateCellHeight_1 = require("./calculateCellHeight");
+/**
+ * Produces an array of values that describe the largest value length (height) in every row.
+ */
+const calculateRowHeights = (rows, config) => {
+    return rows.map((row) => {
+        let rowHeight = 1;
+        row.forEach((cell, cellIndex) => {
+            const cellHeight = calculateCellHeight_1.calculateCellHeight(cell, config.columns[cellIndex].width, config.columns[cellIndex].wrapWord);
+            rowHeight = Math.max(rowHeight, cellHeight);
+        });
+        return rowHeight;
+    });
+};
+exports.calculateRowHeights = calculateRowHeights;

package/dist/createStream.d.ts

@@ -1,3 +1,2 @@
 import type { StreamUserConfig, WritableStream } from './types/api';
-declare const _default: (userConfig: StreamUserConfig) => WritableStream;
-export default _default;
+export declare const createStream: (userConfig: StreamUserConfig) => WritableStream;

package/dist/createStream.js

@@ -1,58 +1,56 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const alignTableData_1 = __importDefault(require("./alignTableData"));
-const calculateRowHeightIndex_1 = __importDefault(require("./calculateRowHeightIndex"));
+exports.createStream = void 0;
+const alignTableData_1 = require("./alignTableData");
+const calculateRowHeights_1 = require("./calculateRowHeights");
 const drawBorder_1 = require("./drawBorder");
-const drawRow_1 = __importDefault(require("./drawRow"));
-const makeStreamConfig_1 = __importDefault(require("./makeStreamConfig"));
-const mapDataUsingRowHeightIndex_1 = __importDefault(require("./mapDataUsingRowHeightIndex"));
-const padTableData_1 = __importDefault(require("./padTableData"));
-const stringifyTableData_1 = __importDefault(require("./stringifyTableData"));
-const truncateTableData_1 = __importDefault(require("./truncateTableData"));
+const drawRow_1 = require("./drawRow");
+const makeStreamConfig_1 = require("./makeStreamConfig");
+const mapDataUsingRowHeights_1 = require("./mapDataUsingRowHeights");
+const padTableData_1 = require("./padTableData");
+const stringifyTableData_1 = require("./stringifyTableData");
+const truncateTableData_1 = require("./truncateTableData");
 const prepareData = (data, config) => {
-    let rows = stringifyTableData_1.default(data);
-    rows = truncateTableData_1.default(rows, config);
-    const rowHeightIndex = calculateRowHeightIndex_1.default(rows, config);
-    rows = mapDataUsingRowHeightIndex_1.default(rows, rowHeightIndex, config);
-    rows = alignTableData_1.default(rows, config);
-    rows = padTableData_1.default(rows, config);
+    let rows = stringifyTableData_1.stringifyTableData(data);
+    rows = truncateTableData_1.truncateTableData(rows, config);
+    const rowHeights = calculateRowHeights_1.calculateRowHeights(rows, config);
+    rows = mapDataUsingRowHeights_1.mapDataUsingRowHeights(rows, rowHeights, config);
+    rows = alignTableData_1.alignTableData(rows, config);
+    rows = padTableData_1.padTableData(rows, config);
     return rows;
 };
-const create = (row, columnWidthIndex, config) => {
+const create = (row, columnWidths, config) => {
     const rows = prepareData([row], config);
     const body = rows.map((literalRow) => {
-        return drawRow_1.default(literalRow, config);
+        return drawRow_1.drawRow(literalRow, config);
     }).join('');
     let output;
     output = '';
-    output += drawBorder_1.drawBorderTop(columnWidthIndex, config);
+    output += drawBorder_1.drawBorderTop(columnWidths, config);
     output += body;
-    output += drawBorder_1.drawBorderBottom(columnWidthIndex, config);
+    output += drawBorder_1.drawBorderBottom(columnWidths, config);
     output = output.trimEnd();
     process.stdout.write(output);
 };
-const append = (row, columnWidthIndex, config) => {
+const append = (row, columnWidths, config) => {
     const rows = prepareData([row], config);
     const body = rows.map((literalRow) => {
-        return drawRow_1.default(literalRow, config);
+        return drawRow_1.drawRow(literalRow, config);
     }).join('');
     let output = '';
-    const bottom = drawBorder_1.drawBorderBottom(columnWidthIndex, config);
+    const bottom = drawBorder_1.drawBorderBottom(columnWidths, config);
     if (bottom !== '\n') {
         output = '\r\u001B[K';
     }
-    output += drawBorder_1.drawBorderJoin(columnWidthIndex, config);
+    output += drawBorder_1.drawBorderJoin(columnWidths, config);
     output += body;
     output += bottom;
     output = output.trimEnd();
     process.stdout.write(output);
 };
-exports.default = (userConfig) => {
-    const config = makeStreamConfig_1.default(userConfig);
-    const columnWidthIndex = Object.values(config.columns).map((column) => {
+const createStream = (userConfig) => {
+    const config = makeStreamConfig_1.makeStreamConfig(userConfig);
+    const columnWidths = Object.values(config.columns).map((column) => {
         return column.width + column.paddingLeft + column.paddingRight;
     });
     let empty = true;
@@ -63,11 +61,12 @@ exports.default = (userConfig) => {
             }
             if (empty) {
                 empty = false;
-                create(row, columnWidthIndex, config);
+                create(row, columnWidths, config);
             }
             else {
-                append(row, columnWidthIndex, config);
+                append(row, columnWidths, config);
             }
         },
     };
 };
+exports.createStream = createStream;

package/dist/drawBorder.d.ts

@@ -1,25 +1,26 @@
 import type { DrawVerticalLine } from './types/api';
-import type { BottomBorderConfig, JoinBorderConfig, TopBorderConfig } from './types/internal';
+import type { TableConfig, SeparatorGetter, TopBorderConfig, JoinBorderConfig, BottomBorderConfig } from './types/internal';
 declare type Separator = {
     readonly left: string;
     readonly right: string;
     readonly body: string;
     readonly join: string;
 };
-declare const drawBorder: (columnSizeIndex: number[], config: {
+declare const drawBorder: (columnWidths: number[], config: {
     separator: Separator;
     drawVerticalLine: DrawVerticalLine;
 }) => string;
-declare const drawBorderTop: (columnSizeIndex: number[], config: {
+declare const drawBorderTop: (columnWidths: number[], config: {
     border: TopBorderConfig;
     drawVerticalLine: DrawVerticalLine;
 }) => string;
-declare const drawBorderJoin: (columnSizeIndex: number[], config: {
+declare const drawBorderJoin: (columnWidths: number[], config: {
     border: JoinBorderConfig;
     drawVerticalLine: DrawVerticalLine;
 }) => string;
-declare const drawBorderBottom: (columnSizeIndex: number[], config: {
+declare const drawBorderBottom: (columnWidths: number[], config: {
     border: BottomBorderConfig;
     drawVerticalLine: DrawVerticalLine;
 }) => string;
+export declare const createTableBorderGetter: (columnWidths: number[], config: TableConfig) => SeparatorGetter;
 export { drawBorder, drawBorderBottom, drawBorderJoin, drawBorderTop, };

package/dist/drawBorder.js

@@ -1,19 +1,28 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.drawBorderTop = exports.drawBorderJoin = exports.drawBorderBottom = exports.drawBorder = void 0;
-const drawHorizontalContent_1 = __importDefault(require("./drawHorizontalContent"));
-const drawBorder = (columnSizeIndex, config) => {
-    const columns = columnSizeIndex.map((size) => {
+exports.drawBorderTop = exports.drawBorderJoin = exports.drawBorderBottom = exports.drawBorder = exports.createTableBorderGetter = void 0;
+const drawContent_1 = require("./drawContent");
+const drawBorder = (columnWidths, config) => {
+    const { separator, drawVerticalLine } = config;
+    const columns = columnWidths.map((size) => {
         return config.separator.body.repeat(size);
     });
-    return drawHorizontalContent_1.default(columns, config);
+    return drawContent_1.drawContent(columns, {
+        drawSeparator: drawVerticalLine,
+        separatorGetter: (index, columnCount) => {
+            if (index === 0) {
+                return separator.left;
+            }
+            if (index === columnCount) {
+                return separator.right;
+            }
+            return separator.join;
+        },
+    }) + '\n';
 };
 exports.drawBorder = drawBorder;
-const drawBorderTop = (columnSizeIndex, config) => {
-    const result = drawBorder(columnSizeIndex, {
+const drawBorderTop = (columnWidths, config) => {
+    const result = drawBorder(columnWidths, {
         ...config,
         separator: {
             body: config.border.topBody,
@@ -28,8 +37,8 @@ const drawBorderTop = (columnSizeIndex, config) => {
     return result;
 };
 exports.drawBorderTop = drawBorderTop;
-const drawBorderJoin = (columnSizeIndex, config) => {
-    return drawBorder(columnSizeIndex, {
+const drawBorderJoin = (columnWidths, config) => {
+    return drawBorder(columnWidths, {
         ...config,
         separator: {
             body: config.border.joinBody,
@@ -40,8 +49,8 @@ const drawBorderJoin = (columnSizeIndex, config) => {
     });
 };
 exports.drawBorderJoin = drawBorderJoin;
-const drawBorderBottom = (columnSizeIndex, config) => {
-    return drawBorder(columnSizeIndex, {
+const drawBorderBottom = (columnWidths, config) => {
+    return drawBorder(columnWidths, {
         ...config,
         separator: {
             body: config.border.bottomBody,
@@ -52,3 +61,40 @@ const drawBorderBottom = (columnSizeIndex, config) => {
     });
 };
 exports.drawBorderBottom = drawBorderBottom;
+const createTableBorderGetter = (columnWidths, config) => {
+    return (index, size) => {
+        if (!config.header) {
+            if (index === 0) {
+                return drawBorderTop(columnWidths, config);
+            }
+            if (index === size) {
+                return drawBorderBottom(columnWidths, config);
+            }
+            return drawBorderJoin(columnWidths, config);
+        }
+        // Deal with the header
+        if (index === 0) {
+            return drawBorderTop(columnWidths, {
+                ...config,
+                border: {
+                    ...config.border,
+                    topJoin: config.border.topBody,
+                },
+            });
+        }
+        if (index === 1) {
+            return drawBorderJoin(columnWidths, {
+                ...config,
+                border: {
+                    ...config.border,
+                    joinJoin: config.border.headerJoin,
+                },
+            });
+        }
+        if (index === size) {
+            return drawBorderBottom(columnWidths, config);
+        }
+        return drawBorderJoin(columnWidths, config);
+    };
+};
+exports.createTableBorderGetter = createTableBorderGetter;

package/dist/drawContent.d.ts

@@ -0,0 +1,9 @@
+declare type SeparatorConfig = {
+    drawSeparator: (index: number, size: number) => boolean;
+    separatorGetter: (index: number, size: number) => string;
+};
+/**
+ * Shared function to draw horizontal borders, rows or the entire table
+ */
+export declare const drawContent: (contents: string[], separatorConfig: SeparatorConfig) => string;
+export {};

package/dist/drawContent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawContent = void 0;
+/**
+ * Shared function to draw horizontal borders, rows or the entire table
+ */
+const drawContent = (contents, separatorConfig) => {
+    const { separatorGetter, drawSeparator } = separatorConfig;
+    const contentSize = contents.length;
+    const result = [];
+    if (drawSeparator(0, contentSize)) {
+        result.push(separatorGetter(0, contentSize));
+    }
+    contents.forEach((content, contentIndex) => {
+        result.push(content);
+        // Only append the middle separator if the content is not the last
+        if (contentIndex + 1 < contentSize && drawSeparator(contentIndex + 1, contentSize)) {
+            result.push(separatorGetter(contentIndex + 1, contentSize));
+        }
+    });
+    if (drawSeparator(contentSize, contentSize)) {
+        result.push(separatorGetter(contentSize, contentSize));
+    }
+    return result.join('');
+};
+exports.drawContent = drawContent;

package/dist/drawHeader.d.ts

@@ -0,0 +1,2 @@
+import type { TableConfig } from './types/internal';
+export declare const drawHeader: (width: number, config: TableConfig) => string;

package/dist/drawHeader.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawHeader = void 0;
+const alignString_1 = require("./alignString");
+const drawRow_1 = require("./drawRow");
+const padTableData_1 = require("./padTableData");
+const truncateTableData_1 = require("./truncateTableData");
+const wrapCell_1 = require("./wrapCell");
+const drawHeader = (width, config) => {
+    if (!config.header) {
+        throw new Error('Can not draw header without header configuration');
+    }
+    const { alignment, paddingRight, paddingLeft, wrapWord } = config.header;
+    let content = config.header.content;
+    content = truncateTableData_1.truncateString(content, config.header.truncate);
+    const headerLines = wrapCell_1.wrapCell(content, width, wrapWord);
+    return headerLines.map((headerLine) => {
+        let line = alignString_1.alignString(headerLine, width, alignment);
+        line = padTableData_1.padString(line, paddingLeft, paddingRight);
+        return drawRow_1.drawRow([line], {
+            ...config,
+            drawVerticalLine: (index) => {
+                const columnCount = config.columns.length;
+                return config.drawVerticalLine(index === 0 ? 0 : columnCount, columnCount);
+            },
+        });
+    }).join('');
+};
+exports.drawHeader = drawHeader;

package/dist/drawRow.d.ts

@@ -1,7 +1,6 @@
 import type { DrawVerticalLine } from './types/api';
 import type { BodyBorderConfig, Row } from './types/internal';
-declare const _default: (row: Row, config: {
+export declare const drawRow: (row: Row, config: {
     border: BodyBorderConfig;
     drawVerticalLine: DrawVerticalLine;
 }) => string;
-export default _default;

package/dist/drawRow.js

@@ -1,16 +1,20 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const drawHorizontalContent_1 = __importDefault(require("./drawHorizontalContent"));
-exports.default = (row, config) => {
-    return drawHorizontalContent_1.default(row, {
-        ...config,
-        separator: {
-            join: config.border.bodyJoin,
-            left: config.border.bodyLeft,
-            right: config.border.bodyRight,
+exports.drawRow = void 0;
+const drawContent_1 = require("./drawContent");
+const drawRow = (row, config) => {
+    const { border, drawVerticalLine } = config;
+    return drawContent_1.drawContent(row, {
+        drawSeparator: drawVerticalLine,
+        separatorGetter: (index, columnCount) => {
+            if (index === 0) {
+                return border.bodyLeft;
+            }
+            if (index === columnCount) {
+                return border.bodyRight;
+            }
+            return border.bodyJoin;
         },
-    });
+    }) + '\n';
 };
+exports.drawRow = drawRow;

package/dist/drawTable.d.ts

@@ -1,3 +1,2 @@
 import type { TableConfig, Row } from './types/internal';
-declare const _default: (rows: Row[], columnWidths: number[], rowHeights: number[], config: TableConfig) => string;
-export default _default;
+export declare const drawTable: (rows: Row[], columnWidths: number[], rowHeights: number[], config: TableConfig) => string;