table 6.7.3 → 6.7.4

package/dist/test/README/usage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../../src");
+const utils_1 = require("../utils");
+describe('README.md usage/', () => {
+    it('basic', () => {
+        const data = [
+            ['0A', '0B', '0C'],
+            ['1A', '1B', '1C'],
+            ['2A', '2B', '2C'],
+        ];
+        const output = (0, src_1.table)(data);
+        (0, utils_1.expectTable)(output, `
+╔════╤════╤════╗
+║ 0A │ 0B │ 0C ║
+╟────┼────┼────╢
+║ 1A │ 1B │ 1C ║
+╟────┼────┼────╢
+║ 2A │ 2B │ 2C ║
+╚════╧════╧════╝
+        `);
+    });
+});
+//# sourceMappingURL=usage.js.map

package/dist/test/alignString.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/alignString.js

@@ -0,0 +1,124 @@
+"use strict";
+/* eslint-disable max-nested-callbacks */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chalk_1 = __importDefault(require("chalk"));
+const alignString_1 = require("../src/alignString");
+const utils_1 = require("./utils");
+describe('alignString', () => {
+    context('subject parameter value width is greater than the container width', () => {
+        it('throws an error', () => {
+            (0, chai_1.expect)(() => {
+                (0, alignString_1.alignString)('aa', 1, 'left');
+            }).to.throw(Error, 'Subject parameter value width cannot be greater than the container width.');
+        });
+    });
+    context('subject parameter value', () => {
+        context('0 width', () => {
+            it('produces a string consisting of container width number of whitespace characters', () => {
+                (0, chai_1.expect)((0, alignString_1.alignString)('', 5, 'left')).to.equal('     ', 'left');
+                (0, chai_1.expect)((0, alignString_1.alignString)('', 5, 'center')).to.equal('     ', 'center');
+                (0, chai_1.expect)((0, alignString_1.alignString)('', 5, 'justify')).to.equal('     ', 'justify');
+                (0, chai_1.expect)((0, alignString_1.alignString)('', 5, 'right')).to.equal('     ', 'right');
+            });
+        });
+        context('plain text', () => {
+            context('alignment', () => {
+                context('left', () => {
+                    it('pads the string on the right side using a whitespace character', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)('aa', 6, 'left')).to.equal('aa    ');
+                    });
+                });
+                context('right', () => {
+                    it('pads the string on the left side using a whitespace character', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)('aa', 6, 'right')).to.equal('    aa');
+                    });
+                });
+                context('center', () => {
+                    it('pads the string on both sides using a whitespace character', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)('aa', 8, 'center')).to.equal('   aa   ');
+                    });
+                    context('uneven number of available with', () => {
+                        it('floors the available width; adds extra space to the end of the string', () => {
+                            (0, chai_1.expect)((0, alignString_1.alignString)('aa', 7, 'center')).to.equal('  aa   ');
+                        });
+                    });
+                });
+                context('justify', () => {
+                    it('align left if not contain spaces', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)('aa', 5, 'justify')).to.equal('aa   ');
+                    });
+                    it('add missing spaces between two words', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a a', 5, 'justify')).to.equal('a   a');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a  a', 5, 'justify')).to.equal('a   a');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a   a', 5, 'justify')).to.equal('a   a');
+                    });
+                    it('multiple words, distribute spaces from left to right when maximum adding spaces in one place are not greater than 3', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 5, 'justify')).to.equal('a b c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 6, 'justify')).to.equal('a  b c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 7, 'justify')).to.equal('a  b  c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 8, 'justify')).to.equal('a   b  c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 9, 'justify')).to.equal('a   b   c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 10, 'justify')).to.equal('a    b   c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 11, 'justify')).to.equal('a    b    c');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a b c', 12, 'justify')).to.equal('a b c       ');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a  bbb cc d', 11, 'justify')).to.equal('a  bbb cc d');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a  bbb cc d', 12, 'justify')).to.equal('a   bbb cc d');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a  bbb cc d', 13, 'justify')).to.equal('a   bbb  cc d');
+                        (0, chai_1.expect)((0, alignString_1.alignString)('a  bbb cc d', 14, 'justify')).to.equal('a   bbb  cc  d');
+                    });
+                });
+            });
+        });
+        context('text containing ANSI escape codes', () => {
+            context('alignment', () => {
+                context('left', () => {
+                    it('pads the string on the right side using a whitespace character', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)(chalk_1.default.red('aa'), 6, 'left')).to.equal(chalk_1.default.red('aa') + '    ');
+                    });
+                });
+                context('right', () => {
+                    it('pads the string on the left side using a whitespace character', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)(chalk_1.default.red('aa'), 6, 'right')).to.equal('    ' + chalk_1.default.red('aa'));
+                    });
+                });
+                context('center', () => {
+                    it('pads the string on both sides using a whitespace character', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)(chalk_1.default.red('aa'), 6, 'center')).to.equal('  ' + chalk_1.default.red('aa') + '  ');
+                    });
+                    context('uneven number of available with', () => {
+                        it('floors the available width; adds extra space to the end of the string', () => {
+                            (0, chai_1.expect)((0, alignString_1.alignString)(chalk_1.default.red('aa'), 7, 'center')).to.equal('  ' + chalk_1.default.red('aa') + '   ');
+                        });
+                    });
+                });
+                context('justify', () => {
+                    it('align left if not contain spaces', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)(chalk_1.default.red('aa'), 5, 'justify')).to.equal(chalk_1.default.red('aa') + '   ');
+                    });
+                    it('add missing spaces between two words', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a a'), 5, 'justify')).to.equal((0, utils_1.stringToRed)('a   a'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a  a'), 5, 'justify')).to.equal((0, utils_1.stringToRed)('a   a'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a   a'), 5, 'justify')).to.equal((0, utils_1.stringToRed)('a   a'));
+                    });
+                    it('multiple words, uneven spaces add from left to right', () => {
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a b c'), 5, 'justify')).to.equal((0, utils_1.stringToRed)('a b c'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a b c'), 6, 'justify')).to.equal((0, utils_1.stringToRed)('a  b c'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a b c'), 7, 'justify')).to.equal((0, utils_1.stringToRed)('a  b  c'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a b c'), 8, 'justify')).to.equal((0, utils_1.stringToRed)('a   b  c'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a b c'), 9, 'justify')).to.equal((0, utils_1.stringToRed)('a   b   c'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a b c'), 10, 'justify')).to.equal((0, utils_1.stringToRed)('a    b   c'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a  bbb cc d'), 11, 'justify')).to.equal((0, utils_1.stringToRed)('a  bbb cc d'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a  bbb cc d'), 12, 'justify')).to.equal((0, utils_1.stringToRed)('a   bbb cc d'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a  bbb cc d'), 13, 'justify')).to.equal((0, utils_1.stringToRed)('a   bbb  cc d'));
+                        (0, chai_1.expect)((0, alignString_1.alignString)((0, utils_1.stringToRed)('a  bbb cc d'), 14, 'justify')).to.equal((0, utils_1.stringToRed)('a   bbb  cc  d'));
+                    });
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=alignString.js.map

package/dist/test/alignTableData.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/alignTableData.js

@@ -0,0 +1,63 @@
+"use strict";
+/* eslint-disable max-nested-callbacks */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chalk_1 = __importDefault(require("chalk"));
+const alignTableData_1 = require("../src/alignTableData");
+const makeTableConfig_1 = require("../src/makeTableConfig");
+describe('alignTableData', () => {
+    context('when the string width is equal to column width config', () => {
+        it('returns the unchange string', () => {
+            const rows = [['aaa'], [chalk_1.default.red('bbb')]];
+            (0, chai_1.expect)((0, alignTableData_1.alignTableData)(rows, (0, makeTableConfig_1.makeTableConfig)(rows, {
+                columns: {
+                    0: {
+                        width: 3,
+                    },
+                },
+            }))).to.deep.equal(rows);
+        });
+    });
+    context('when the string is different from the column width config', () => {
+        it('aligns cells with column width and alignment config', () => {
+            const rows = [['a', 'b', 'c'],
+                [chalk_1.default.red('a'), chalk_1.default.red('b'), chalk_1.default.red('c')]];
+            (0, chai_1.expect)((0, alignTableData_1.alignTableData)(rows, (0, makeTableConfig_1.makeTableConfig)(rows, {
+                columnDefault: {
+                    width: 3,
+                },
+                columns: {
+                    0: {
+                        alignment: 'left',
+                    },
+                    1: {
+                        alignment: 'right',
+                    },
+                    2: {
+                        alignment: 'center',
+                    },
+                },
+            }))).to.deep.equal([['a  ', '  b', ' c '], [
+                    chalk_1.default.red('a') + '  ', '  ' + chalk_1.default.red('b'), ' ' + chalk_1.default.red('c') + ' ',
+                ]]);
+        });
+    });
+    context('when the string is longer then column width', () => {
+        it('throws an error', () => {
+            const rows = [['aaaa']];
+            (0, chai_1.expect)(() => {
+                (0, alignTableData_1.alignTableData)(rows, (0, makeTableConfig_1.makeTableConfig)(rows, {
+                    columns: {
+                        0: {
+                            width: 3,
+                        },
+                    },
+                }));
+            }).to.throw(Error, 'Subject parameter value width cannot be greater than the container width.');
+        });
+    });
+});
+//# sourceMappingURL=alignTableData.js.map

package/dist/test/calculateCellHeight.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/calculateCellHeight.js

@@ -0,0 +1,28 @@
+"use strict";
+/* eslint-disable max-nested-callbacks */
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const calculateCellHeight_1 = require("../src/calculateCellHeight");
+describe('calculateCellHeight', () => {
+    describe('value', () => {
+        it('contains newlines', () => {
+            (0, chai_1.expect)((0, calculateCellHeight_1.calculateCellHeight)('a\nb\nc', 10)).to.equal(3);
+        });
+        it('contains newlines and will be wrapped', () => {
+            (0, chai_1.expect)((0, calculateCellHeight_1.calculateCellHeight)('aa\nbbb\nc', 2)).to.equal(4);
+        });
+    });
+    describe('context width', () => {
+        context('is lesser than the column width', () => {
+            it('has height 1', () => {
+                (0, chai_1.expect)((0, calculateCellHeight_1.calculateCellHeight)('foo', 10)).to.equal(1);
+            });
+        });
+        context('is 2 and half times greater than the column width', () => {
+            it('has height 3', () => {
+                (0, chai_1.expect)((0, calculateCellHeight_1.calculateCellHeight)('aabbc', 2)).to.equal(3);
+            });
+        });
+    });
+});
+//# sourceMappingURL=calculateCellHeight.js.map

package/dist/test/calculateCellWidths.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/calculateCellWidths.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const calculateCellWidths_1 = require("../src/calculateCellWidths");
+describe('calculateCellWidths', () => {
+    context('all cells have different width', () => {
+        it('describes each cell contents width', () => {
+            const cellWidths = (0, calculateCellWidths_1.calculateCellWidths)([
+                'a',
+                'aaa',
+                'aaaaaa',
+            ]);
+            (0, chai_1.expect)(cellWidths[0]).to.equal(1, 'first column');
+            (0, chai_1.expect)(cellWidths[1]).to.equal(3, 'second column');
+            (0, chai_1.expect)(cellWidths[2]).to.equal(6, 'third column');
+        });
+    });
+    context('cell contains newline characters', () => {
+        it('picks the longest line length', () => {
+            const cellWidths = (0, calculateCellWidths_1.calculateCellWidths)([
+                'aaaa\naa',
+            ]);
+            (0, chai_1.expect)(cellWidths[0]).to.equal(4);
+        });
+    });
+});
+//# sourceMappingURL=calculateCellWidths.js.map

package/dist/test/calculateColumnWidths.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/calculateColumnWidths.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chalk_1 = __importDefault(require("chalk"));
+const calculateColumnWidths_1 = __importDefault(require("../src/calculateColumnWidths"));
+describe('calculateColumnWidths', () => {
+    it('calculates the maximum column value index', () => {
+        const columnWidths = (0, calculateColumnWidths_1.default)([
+            [
+                '',
+                'a',
+                'b',
+                'c',
+            ],
+            [
+                '',
+                'a',
+                'bbbbbbbbbb',
+                'c',
+            ],
+            [
+                '',
+                '',
+                'b',
+                'ccccc',
+            ],
+        ]);
+        (0, chai_1.expect)(columnWidths).to.deep.equal([0, 1, 10, 5]);
+    });
+    context('cell values contain ANSI codes', () => {
+        it('uses visual width of the string', () => {
+            const columnWidths = (0, calculateColumnWidths_1.default)([
+                [
+                    chalk_1.default.red('aaaaa'),
+                ],
+            ]);
+            (0, chai_1.expect)(columnWidths[0]).to.equal(5);
+        });
+    });
+    context('cell values contain fullwidth characters', () => {
+        it('uses visual width of the string', () => {
+            const columnWidths = (0, calculateColumnWidths_1.default)([
+                [
+                    chalk_1.default.red('古'),
+                ],
+            ]);
+            (0, chai_1.expect)(columnWidths[0]).to.equal(2);
+        });
+    });
+});
+//# sourceMappingURL=calculateColumnWidths.js.map

package/dist/test/calculateRowHeights.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/calculateRowHeights.js

@@ -0,0 +1,61 @@
+"use strict";
+/* eslint-disable max-nested-callbacks */
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const calculateRowHeights_1 = require("../src/calculateRowHeights");
+const makeTableConfig_1 = require("../src/makeTableConfig");
+describe('calculateRowHeights', () => {
+    context('single column', () => {
+        context('cell content width is lesser than column width', () => {
+            it('is equal to 1', () => {
+                const data = [['aaa']];
+                const config = (0, makeTableConfig_1.makeTableConfig)(data, {
+                    columns: {
+                        0: {
+                            width: 10,
+                            wrapWord: false,
+                        },
+                    },
+                });
+                const rowHeights = (0, calculateRowHeights_1.calculateRowHeights)(data, config);
+                (0, chai_1.expect)(rowHeights[0]).to.equal(1);
+            });
+        });
+        context('cell content width is twice the size of the column width', () => {
+            it('is equal to 2', () => {
+                const data = [['aaabbb']];
+                const config = (0, makeTableConfig_1.makeTableConfig)(data, {
+                    columns: {
+                        0: {
+                            width: 3,
+                            wrapWord: false,
+                        },
+                    },
+                });
+                const rowHeights = (0, calculateRowHeights_1.calculateRowHeights)(data, config);
+                (0, chai_1.expect)(rowHeights[0]).to.equal(2);
+            });
+        });
+    });
+    context('multiple columns', () => {
+        context('multiple cell content width is greater than the column width', () => {
+            it('uses the largest height', () => {
+                const data = [
+                    ['aaabbb'],
+                    ['aaabbb'],
+                ];
+                const config = (0, makeTableConfig_1.makeTableConfig)(data, {
+                    columns: {
+                        0: {
+                            width: 2,
+                            wrapWord: false,
+                        },
+                    },
+                });
+                const rowHeights = (0, calculateRowHeights_1.calculateRowHeights)(data, config);
+                (0, chai_1.expect)(rowHeights[0]).to.equal(3);
+            });
+        });
+    });
+});
+//# sourceMappingURL=calculateRowHeights.js.map

package/dist/test/createStream.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/createStream.js

@@ -0,0 +1,122 @@
+"use strict";
+/* eslint-disable max-nested-callbacks */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+// eslint-disable-next-line import/no-namespace
+const Sinon = __importStar(require("sinon"));
+const src_1 = require("../src");
+describe('createStream', () => {
+    context('"config.columnDefault.width" property is not provided', () => {
+        it('throws an error', () => {
+            (0, chai_1.expect)(() => {
+                (0, src_1.createStream)({
+                    columnCount: 1,
+                    columnDefault: {},
+                });
+            }).to.throw(Error, 'Must provide config.columnDefault.width when creating a stream.');
+        });
+    });
+    context('Table data cell count does not match the columnCount.', () => {
+        it('throws an error', () => {
+            (0, chai_1.expect)(() => {
+                const stream = (0, src_1.createStream)({
+                    columnCount: 10,
+                    columnDefault: {
+                        width: 10,
+                    },
+                });
+                stream.write(['foo']);
+            }).to.throw(Error, 'Row cell count does not match the config.columnCount.');
+        });
+    });
+    context('normal stream', () => {
+        let stub;
+        beforeEach(() => {
+            stub = Sinon.stub(process.stdout, 'write');
+        });
+        afterEach(() => {
+            stub.restore();
+            stub.resetHistory();
+        });
+        it('process.stdout.write calls twice with proper arguments', () => {
+            const stream = (0, src_1.createStream)({
+                border: (0, src_1.getBorderCharacters)('ramac'),
+                columnCount: 3,
+                columnDefault: {
+                    width: 2,
+                },
+                columns: {
+                    0: {
+                        alignment: 'right',
+                        paddingLeft: 3,
+                    },
+                    1: {
+                        alignment: 'center',
+                        paddingRight: 2,
+                    },
+                    2: {
+                        alignment: 'left',
+                        width: 5,
+                    },
+                },
+            });
+            stream.write(['a b', 'ccc', 'd']);
+            stream.write(['e', 'f', 'g']);
+            Sinon.assert.callCount(stub, 2);
+            Sinon.assert.calledWithExactly(stub.getCall(0), '+------+-----+-------+\n|   a  | cc  | d     |\n|    b | c   |       |\n+------+-----+-------+');
+            Sinon.assert.calledWithExactly(stub.getCall(1), '\r\u001b[K|------|-----|-------|\n|    e | f   | g     |\n+------+-----+-------+');
+        });
+        context('given custom drawVerticalLine', () => {
+            it('use the callback to draw vertical lines', () => {
+                const stream = (0, src_1.createStream)({
+                    columnCount: 2,
+                    columnDefault: {
+                        width: 2,
+                    },
+                    drawVerticalLine: (index) => {
+                        return index === 1;
+                    },
+                });
+                stream.write(['a', 'b']);
+                Sinon.assert.callCount(stub, 1);
+                Sinon.assert.calledOnceWithExactly(stub, '════╤════\n a  │ b  \n════╧════');
+            });
+        });
+        context('append empty row', () => {
+            it('does not add a new line', () => {
+                const stream = (0, src_1.createStream)({
+                    border: (0, src_1.getBorderCharacters)('void'),
+                    columnCount: 1,
+                    columnDefault: {
+                        width: 2,
+                    },
+                });
+                stream.write(['a']);
+                stream.write(['']);
+                stream.write(['a']);
+                Sinon.assert.calledWithExactly(stub.getCall(1), '');
+                Sinon.assert.calledWithExactly(stub.getCall(2), '\n a');
+            });
+        });
+    });
+});
+//# sourceMappingURL=createStream.js.map

package/dist/test/drawBorder.d.ts

@@ -0,0 +1 @@
+export {};