table 6.2.0 → 6.3.0

package/README.md

@@ -699,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.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.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.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.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.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.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.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.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.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.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.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.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';

package/dist/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBorderCharacters = exports.createStream = exports.table = void 0;
+const createStream_1 = __importDefault(require("./createStream"));
+exports.createStream = createStream_1.default;
+const getBorderCharacters_1 = __importDefault(require("./getBorderCharacters"));
+exports.getBorderCharacters = getBorderCharacters_1.default;
+const table_1 = __importDefault(require("./table"));
+exports.table = table_1.default;
+__exportStar(require("./types/api"), exports);
+//# sourceMappingURL=index.js.map

package/dist/src/makeConfig.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const calculateMaximumColumnWidthIndex_1 = __importDefault(require("./calculateMaximumColumnWidthIndex"));
+const getBorderCharacters_1 = __importDefault(require("./getBorderCharacters"));
+const validateConfig_1 = __importDefault(require("./validateConfig"));
+/**
+ * Merges user provided border characters with the default border ("honeywell") characters.
+ */
+const makeBorder = (border) => {
+    return {
+        ...getBorderCharacters_1.default('honeywell'),
+        ...border,
+    };
+};
+/**
+ * Creates a configuration for every column using default
+ * values for the missing configuration properties.
+ */
+const makeColumns = (rows, columns, columnDefault) => {
+    const maximumColumnWidthIndex = calculateMaximumColumnWidthIndex_1.default(rows);
+    return rows[0].map((_cell, index) => {
+        return {
+            alignment: 'left',
+            paddingLeft: 1,
+            paddingRight: 1,
+            truncate: Number.POSITIVE_INFINITY,
+            width: maximumColumnWidthIndex[index],
+            wrapWord: false,
+            ...columnDefault,
+            ...columns === null || columns === void 0 ? void 0 : columns[index],
+        };
+    });
+};
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+exports.default = (rows, userConfig = {}) => {
+    var _a, _b, _c;
+    validateConfig_1.default('config.json', userConfig);
+    const config = lodash_clonedeep_1.default(userConfig);
+    return {
+        ...config,
+        border: makeBorder(config.border),
+        columns: makeColumns(rows, config.columns, config.columnDefault),
+        drawHorizontalLine: (_a = config.drawHorizontalLine) !== null && _a !== void 0 ? _a : (() => {
+            return true;
+        }),
+        drawVerticalLine: (_b = config.drawVerticalLine) !== null && _b !== void 0 ? _b : (() => {
+            return true;
+        }),
+        singleLine: (_c = config.singleLine) !== null && _c !== void 0 ? _c : false,
+    };
+};
+//# sourceMappingURL=makeConfig.js.map

package/dist/src/makeStreamConfig.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const getBorderCharacters_1 = __importDefault(require("./getBorderCharacters"));
+const validateConfig_1 = __importDefault(require("./validateConfig"));
+/**
+ * Merges user provided border characters with the default border ("honeywell") characters.
+ *
+ */
+const makeBorder = (border) => {
+    return {
+        ...getBorderCharacters_1.default('honeywell'),
+        ...border,
+    };
+};
+/**
+ * Creates a configuration for every column using default
+ * values for the missing configuration properties.
+ */
+const makeColumns = (columnCount, columns = {}, columnDefault) => {
+    return Array.from({ length: columnCount }).map((_, index) => {
+        return {
+            alignment: 'left',
+            paddingLeft: 1,
+            paddingRight: 1,
+            truncate: Number.POSITIVE_INFINITY,
+            wrapWord: false,
+            ...columnDefault,
+            ...columns[index],
+        };
+    });
+};
+/**
+ * Makes a new configuration object out of the userConfig object
+ * using default values for the missing configuration properties.
+ */
+exports.default = (userConfig) => {
+    var _a;
+    validateConfig_1.default('streamConfig.json', userConfig);
+    const config = lodash_clonedeep_1.default(userConfig);
+    if (!config.columnDefault || !config.columnDefault.width) {
+        throw new Error('Must provide config.columnDefault.width when creating a stream.');
+    }
+    if (!config.columnCount) {
+        throw new Error('Must provide config.columnCount.');
+    }
+    return {
+        ...config,
+        border: makeBorder(config.border),
+        columnCount: config.columnCount,
+        columns: makeColumns(config.columnCount, config.columns, config.columnDefault),
+        drawVerticalLine: (_a = config.drawVerticalLine) !== null && _a !== void 0 ? _a : (() => {
+            return true;
+        }),
+    };
+};
+//# sourceMappingURL=makeStreamConfig.js.map

package/dist/src/mapDataUsingRowHeightIndex.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_flatten_1 = __importDefault(require("lodash.flatten"));
+const wrapCell_1 = __importDefault(require("./wrapCell"));
+exports.default = (unmappedRows, rowHeightIndex, config) => {
+    const tableWidth = unmappedRows[0].length;
+    const mappedRows = unmappedRows.map((row, index0) => {
+        const rowHeight = Array.from({ length: rowHeightIndex[index0] }, () => {
+            return new Array(tableWidth).fill('');
+        });
+        // rowHeight
+        //     [{row index within rowSaw; index2}]
+        //     [{cell index within a virtual row; index1}]
+        row.forEach((cell, index1) => {
+            const cellLines = wrapCell_1.default(cell, config.columns[index1].width, config.columns[index1].wrapWord);
+            cellLines.forEach((cellLine, index2) => {
+                rowHeight[index2][index1] = cellLine;
+            });
+        });
+        return rowHeight;
+    });
+    return lodash_flatten_1.default(mappedRows);
+};
+//# sourceMappingURL=mapDataUsingRowHeightIndex.js.map