table 6.0.9 → 6.3.1

package/README.md

@@ -14,6 +14,7 @@
         * [Cell Content Alignment](#table-usage-cell-content-alignment)
         * [Column Width](#table-usage-column-width)
         * [Custom Border](#table-usage-custom-border)
+        * [Draw Vertical Line](#table-usage-draw-vertical-line)
         * [Draw Horizontal Line](#table-usage-draw-horizontal-line)
         * [Single Line Mode](#table-usage-single-line-mode)
         * [Padding Cell Content](#table-usage-padding-cell-content)
@@ -292,6 +293,57 @@ console.log(output);
 └────┴────┴────┘
 ```
 
+<a name="table-usage-draw-vertical-line"></a>
+### Draw Vertical Line
+
+`{function} config.drawVerticalLine` property is a function that is called for every non-content column in the table. The result of the function `{boolean}` determines whether a border is drawn.
+
+```js
+let data,
+  output,
+  options;
+
+data = [
+  ['0A', '0B', '0C'],
+  ['1A', '1B', '1C'],
+  ['2A', '2B', '2C'],
+  ['3A', '3B', '3C'],
+  ['4A', '4B', '4C']
+];
+
+options = {
+  /**
+    * @typedef {function} drawVerticalLine
+    * @param {number} index
+    * @param {number} size
+    * @return {boolean}
+    */
+  drawVerticalLine: (index, size) => {
+    return index === 0 || index === size;
+  }
+};
+
+output = table(data, options);
+
+console.log(output);
+
+```
+
+```
+╔════════════╗
+║ 0A  0B  0C ║
+╟────────────╢
+║ 1A  1B  1C ║
+╟────────────╢
+║ 2A  2B  2C ║
+╟────────────╢
+║ 3A  3B  3C ║
+╟────────────╢
+║ 4A  4B  4C ║
+╚════════════╝
+
+```
+
 <a name="table-usage-draw-horizontal-line"></a>
 ### Draw Horizontal Line
 
@@ -647,7 +699,7 @@ console.log(output);
 ║ t amet, consectetur  ║
 ║ adipiscing elit. Pha ║
 ║ sellus pulvinar nibh ║
-║ sed mauris conva...  ║
+║ sed mauris convall…  ║
 ╚══════════════════════╝
 ```
 

package/dist/src/alignString.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (subject: string, containerWidth: number, alignment: string) => string;
+/**
+ * Pads a string to the left and/or right to position the subject
+ * text in a desired alignment within a container.
+ */
+export default _default;

package/dist/src/alignString.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_number_object_1 = __importDefault(require("is-number-object"));
+const is_string_1 = __importDefault(require("is-string"));
+const string_width_1 = __importDefault(require("string-width"));
+const alignLeft = (subject, width) => {
+    return subject + ' '.repeat(width);
+};
+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);
+    }
+    else {
+        halfWidth = Math.floor(halfWidth);
+        return ' '.repeat(halfWidth) + subject + ' '.repeat(halfWidth + 1);
+    }
+};
+const alignments = [
+    'left',
+    'right',
+    'center',
+];
+/**
+ * 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 (!is_string_1.default(subject)) {
+        throw new TypeError('Subject parameter value must be a string.');
+    }
+    if (!is_number_object_1.default(containerWidth)) {
+        throw new TypeError('Container width parameter value must be a number.');
+    }
+    const subjectWidth = string_width_1.default(subject);
+    if (subjectWidth > containerWidth) {
+        throw new Error('Subject parameter value width cannot be greater than the container width.');
+    }
+    if (!is_string_1.default(alignment)) {
+        throw new TypeError('Alignment parameter value must be a string.');
+    }
+    if (!alignments.includes(alignment)) {
+        throw new Error('Alignment parameter value must be a known alignment parameter value (left, right, center).');
+    }
+    if (subjectWidth === 0) {
+        return ' '.repeat(containerWidth);
+    }
+    const availableWidth = containerWidth - subjectWidth;
+    if (alignment === 'left') {
+        return alignLeft(subject, availableWidth);
+    }
+    if (alignment === 'right') {
+        return alignRight(subject, availableWidth);
+    }
+    return alignCenter(subject, availableWidth);
+};
+//# sourceMappingURL=alignString.js.map

package/dist/src/alignTableData.d.ts

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

package/dist/src/alignTableData.js

@@ -0,0 +1,21 @@
+"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) => {
+    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);
+            }
+        });
+    });
+};
+//# sourceMappingURL=alignTableData.js.map

package/dist/src/calculateCellHeight.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (value: string, columnWidth: number, useWrapWord?: boolean) => number;
+export default _default;

package/dist/src/calculateCellHeight.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_string_1 = __importDefault(require("is-string"));
+const wrapCell_1 = __importDefault(require("./wrapCell"));
+exports.default = (value, columnWidth, useWrapWord = false) => {
+    if (!is_string_1.default(value)) {
+        throw new TypeError('Value must be a string.');
+    }
+    if (!Number.isInteger(columnWidth) || columnWidth < 1) {
+        throw new TypeError('Column width must be an integer greater than 0.');
+    }
+    return wrapCell_1.default(value, columnWidth, useWrapWord).length;
+};
+//# sourceMappingURL=calculateCellHeight.js.map

package/dist/src/calculateCellWidthIndex.d.ts

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

package/dist/src/calculateCellWidthIndex.js

@@ -0,0 +1,17 @@
+"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"));
+/**
+ * Calculates width of each cell contents.
+ */
+exports.default = (cells) => {
+    return cells.map((value) => {
+        return Math.max(...value.split('\n').map((line) => {
+            return string_width_1.default(line);
+        }));
+    });
+};
+//# sourceMappingURL=calculateCellWidthIndex.js.map

package/dist/src/calculateMaximumColumnWidthIndex.d.ts

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

package/dist/src/calculateMaximumColumnWidthIndex.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const calculateCellWidthIndex_1 = __importDefault(require("./calculateCellWidthIndex"));
+/**
+ * Produces an array of values that describe the largest value length (width) in every column.
+ */
+exports.default = (rows) => {
+    if (!rows[0]) {
+        throw new Error('Dataset must have at least one row.');
+    }
+    const columns = new Array(rows[0].length).fill(0);
+    rows.forEach((row) => {
+        const columnWidthIndex = calculateCellWidthIndex_1.default(row);
+        columnWidthIndex.forEach((valueWidth, index0) => {
+            if (columns[index0] < valueWidth) {
+                columns[index0] = valueWidth;
+            }
+        });
+    });
+    return columns;
+};
+//# sourceMappingURL=calculateMaximumColumnWidthIndex.js.map

package/dist/src/calculateRowHeightIndex.d.ts

@@ -0,0 +1,6 @@
+import type { BaseConfig, Row } from './types/internal';
+declare const _default: (rows: Row[], config: BaseConfig) => number[];
+/**
+ * Calculates the vertical row span index.
+ */
+export default _default;

package/dist/src/calculateRowHeightIndex.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_boolean_object_1 = __importDefault(require("is-boolean-object"));
+const is_number_object_1 = __importDefault(require("is-number-object"));
+const calculateCellHeight_1 = __importDefault(require("./calculateCellHeight"));
+/**
+ * Calculates the vertical row span index.
+ */
+exports.default = (rows, config) => {
+    const tableWidth = rows[0].length;
+    const rowSpanIndex = [];
+    rows.forEach((cells) => {
+        const cellHeightIndex = new Array(tableWidth).fill(1);
+        cells.forEach((value, index1) => {
+            if (!is_number_object_1.default(config.columns[index1].width)) {
+                throw new TypeError('column[index].width must be a number.');
+            }
+            if (!is_boolean_object_1.default(config.columns[index1].wrapWord)) {
+                throw new TypeError('column[index].wrapWord must be a boolean.');
+            }
+            cellHeightIndex[index1] = calculateCellHeight_1.default(value, config.columns[index1].width, config.columns[index1].wrapWord);
+        });
+        rowSpanIndex.push(Math.max(...cellHeightIndex));
+    });
+    return rowSpanIndex;
+};
+//# sourceMappingURL=calculateRowHeightIndex.js.map

package/dist/src/createStream.d.ts

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

package/dist/src/createStream.js

@@ -0,0 +1,74 @@
+"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"));
+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 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);
+    return rows;
+};
+const create = (row, columnWidthIndex, config) => {
+    const rows = prepareData([row], config);
+    const body = rows.map((literalRow) => {
+        return drawRow_1.default(literalRow, config);
+    }).join('');
+    let output;
+    output = '';
+    output += drawBorder_1.drawBorderTop(columnWidthIndex, config);
+    output += body;
+    output += drawBorder_1.drawBorderBottom(columnWidthIndex, config);
+    output = output.trimEnd();
+    process.stdout.write(output);
+};
+const append = (row, columnWidthIndex, config) => {
+    const rows = prepareData([row], config);
+    const body = rows.map((literalRow) => {
+        return drawRow_1.default(literalRow, config);
+    }).join('');
+    let output = '';
+    const bottom = drawBorder_1.drawBorderBottom(columnWidthIndex, config);
+    if (bottom !== '\n') {
+        output = '\r\u001B[K';
+    }
+    output += drawBorder_1.drawBorderJoin(columnWidthIndex, 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) => {
+        return column.width + column.paddingLeft + column.paddingRight;
+    });
+    let empty = true;
+    return {
+        write: (row) => {
+            if (row.length !== config.columnCount) {
+                throw new Error('Row cell count does not match the config.columnCount.');
+            }
+            if (empty) {
+                empty = false;
+                create(row, columnWidthIndex, config);
+            }
+            else {
+                append(row, columnWidthIndex, config);
+            }
+        },
+    };
+};
+//# sourceMappingURL=createStream.js.map

package/dist/src/drawBorder.d.ts

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

package/dist/src/drawBorder.js

@@ -0,0 +1,55 @@
+"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) => {
+        return config.separator.body.repeat(size);
+    });
+    return drawHorizontalContent_1.default(columns, config);
+};
+exports.drawBorder = drawBorder;
+const drawBorderTop = (columnSizeIndex, config) => {
+    const result = drawBorder(columnSizeIndex, {
+        ...config,
+        separator: {
+            body: config.border.topBody,
+            join: config.border.topJoin,
+            left: config.border.topLeft,
+            right: config.border.topRight,
+        },
+    });
+    if (result === '\n') {
+        return '';
+    }
+    return result;
+};
+exports.drawBorderTop = drawBorderTop;
+const drawBorderJoin = (columnSizeIndex, config) => {
+    return drawBorder(columnSizeIndex, {
+        ...config,
+        separator: {
+            body: config.border.joinBody,
+            join: config.border.joinJoin,
+            left: config.border.joinLeft,
+            right: config.border.joinRight,
+        },
+    });
+};
+exports.drawBorderJoin = drawBorderJoin;
+const drawBorderBottom = (columnSizeIndex, config) => {
+    return drawBorder(columnSizeIndex, {
+        ...config,
+        separator: {
+            body: config.border.bottomBody,
+            join: config.border.bottomJoin,
+            left: config.border.bottomLeft,
+            right: config.border.bottomRight,
+        },
+    });
+};
+exports.drawBorderBottom = drawBorderBottom;
+//# sourceMappingURL=drawBorder.js.map

package/dist/src/drawHorizontalContent.d.ts

@@ -0,0 +1,11 @@
+import type { DrawVerticalLine } from './types/api';
+declare type Separator = {
+    readonly left: string;
+    readonly right: string;
+    readonly join: string;
+};
+export default function drawHorizontalContent(contents: string[], config: {
+    separator: Separator;
+    drawVerticalLine: DrawVerticalLine;
+}): string;
+export {};

package/dist/src/drawHorizontalContent.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function drawHorizontalContent(contents, config) {
+    const { separator, drawVerticalLine } = config;
+    const contentSize = contents.length;
+    const result = [];
+    result.push(drawVerticalLine(0, contentSize) ? separator.left : '');
+    contents.forEach((content, index) => {
+        result.push(content);
+        // Only append the join separator if it is not the last content
+        if (index + 1 < contentSize) {
+            result.push(drawVerticalLine(index + 1, contentSize) ? separator.join : '');
+        }
+    });
+    result.push(drawVerticalLine(contentSize, contentSize) ? separator.right : '');
+    return result.join('') + '\n';
+}
+exports.default = drawHorizontalContent;
+//# sourceMappingURL=drawHorizontalContent.js.map

package/dist/src/drawRow.d.ts

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

package/dist/src/drawRow.js

@@ -0,0 +1,17 @@
+"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,
+        },
+    });
+};
+//# sourceMappingURL=drawRow.js.map

package/dist/src/drawTable.d.ts

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

package/dist/src/drawTable.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const drawBorder_1 = require("./drawBorder");
+const drawRow_1 = __importDefault(require("./drawRow"));
+exports.default = (rows, columnSizeIndex, rowSpanIndex, config) => {
+    const { drawHorizontalLine, singleLine, } = config;
+    let output;
+    let realRowIndex;
+    let rowHeight;
+    const rowCount = rows.length;
+    realRowIndex = 0;
+    output = '';
+    if (drawHorizontalLine(realRowIndex, rowCount)) {
+        output += drawBorder_1.drawBorderTop(columnSizeIndex, config);
+    }
+    rows.forEach((row, index0) => {
+        output += drawRow_1.default(row, config);
+        if (!rowHeight) {
+            rowHeight = rowSpanIndex[realRowIndex];
+            realRowIndex++;
+        }
+        rowHeight--;
+        if (!singleLine &&
+            rowHeight === 0 &&
+            index0 !== rowCount - 1 &&
+            drawHorizontalLine(realRowIndex, rowCount)) {
+            output += drawBorder_1.drawBorderJoin(columnSizeIndex, config);
+        }
+    });
+    if (drawHorizontalLine(realRowIndex, rowCount)) {
+        output += drawBorder_1.drawBorderBottom(columnSizeIndex, config);
+    }
+    return output;
+};
+//# sourceMappingURL=drawTable.js.map

package/dist/src/getBorderCharacters.d.ts

@@ -0,0 +1,3 @@
+import type { BorderConfig } from './types/api';
+declare const _default: (name: string) => BorderConfig;
+export default _default;

package/dist/src/getBorderCharacters.js

@@ -0,0 +1,83 @@
+"use strict";
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (name) => {
+    if (name === 'honeywell') {
+        return {
+            topBody: '═',
+            topJoin: '╤',
+            topLeft: '╔',
+            topRight: '╗',
+            bottomBody: '═',
+            bottomJoin: '╧',
+            bottomLeft: '╚',
+            bottomRight: '╝',
+            bodyLeft: '║',
+            bodyRight: '║',
+            bodyJoin: '│',
+            joinBody: '─',
+            joinLeft: '╟',
+            joinRight: '╢',
+            joinJoin: '┼',
+        };
+    }
+    if (name === 'norc') {
+        return {
+            topBody: '─',
+            topJoin: '┬',
+            topLeft: '┌',
+            topRight: '┐',
+            bottomBody: '─',
+            bottomJoin: '┴',
+            bottomLeft: '└',
+            bottomRight: '┘',
+            bodyLeft: '│',
+            bodyRight: '│',
+            bodyJoin: '│',
+            joinBody: '─',
+            joinLeft: '├',
+            joinRight: '┤',
+            joinJoin: '┼',
+        };
+    }
+    if (name === 'ramac') {
+        return {
+            topBody: '-',
+            topJoin: '+',
+            topLeft: '+',
+            topRight: '+',
+            bottomBody: '-',
+            bottomJoin: '+',
+            bottomLeft: '+',
+            bottomRight: '+',
+            bodyLeft: '|',
+            bodyRight: '|',
+            bodyJoin: '|',
+            joinBody: '-',
+            joinLeft: '|',
+            joinRight: '|',
+            joinJoin: '|',
+        };
+    }
+    if (name === 'void') {
+        return {
+            topBody: '',
+            topJoin: '',
+            topLeft: '',
+            topRight: '',
+            bottomBody: '',
+            bottomJoin: '',
+            bottomLeft: '',
+            bottomRight: '',
+            bodyLeft: '',
+            bodyRight: '',
+            bodyJoin: '',
+            joinBody: '',
+            joinLeft: '',
+            joinRight: '',
+            joinJoin: '',
+        };
+    }
+    throw new Error('Unknown border template "' + name + '".');
+};
+//# sourceMappingURL=getBorderCharacters.js.map

package/dist/{index.js.flow → src/index.d.ts}

@@ -1,9 +1,5 @@
 import createStream from './createStream';
 import getBorderCharacters from './getBorderCharacters';
 import table from './table';
-
-export {
-  table,
-  createStream,
-  getBorderCharacters,
-};
+export { table, createStream, getBorderCharacters, };
+export * from './types/api';