lib: align console.table row to the left

PR-URL: #50135
Fixes: #50117
Reviewed-By: Benjamin Gruenbaum <[email protected]>
Reviewed-By: Trivikram Kamat <[email protected]>

Author: MrJithil

lib/internal/cli_table.js

@@ -40,11 +40,10 @@ const renderRow = (row, columnWidths) => {
   for (let i = 0; i < row.length; i++) {
     const cell = row[i];
     const len = getStringWidth(cell);
-    const needed = (columnWidths[i] - len) / 2;
+    const needed = (columnWidths[i] - len);
     // round(needed) + ceil(needed) will always add up to the amount
     // of spaces we need while also left justifying the output.
-    out += StringPrototypeRepeat(' ', needed) + cell +
-           StringPrototypeRepeat(' ', MathCeil(needed));
+    out += cell + StringPrototypeRepeat(' ', MathCeil(needed));
     if (i !== row.length - 1)
       out += tableChars.middle;
   }

test/parallel/test-console-table.js

@@ -38,124 +38,124 @@ test([1, 2, 3], `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
-│    0    │   1    │
-│    1    │   2    │
-│    2    │   3    │
+│ 0       │ 1      │
+│ 1       │ 2      │
+│ 2       │ 3      │
 └─────────┴────────┘
 `);
 
 test([Symbol(), 5, [10]], `
 ┌─────────┬────┬──────────┐
-│ (index) │ 0  │  Values  │
+│ (index) │ 0  │ Values   │
 ├─────────┼────┼──────────┤
-│    0    │    │ Symbol() │
-│    1    │    │    5     │
-│    2    │ 10 │          │
+│ 0       │    │ Symbol() │
+│ 1       │    │ 5        │
+│ 2       │ 10 │          │
 └─────────┴────┴──────────┘
 `);
 
 test([null, 5], `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
-│    0    │  null  │
-│    1    │   5    │
+│ 0       │ null   │
+│ 1       │ 5      │
 └─────────┴────────┘
 `);
 
 test([undefined, 5], `
 ┌─────────┬───────────┐
-│ (index) │  Values   │
+│ (index) │ Values    │
 ├─────────┼───────────┤
-│    0    │ undefined │
-│    1    │     5     │
+│ 0       │ undefined │
+│ 1       │ 5         │
 └─────────┴───────────┘
 `);
 
 test({ a: 1, b: Symbol(), c: [10] }, `
 ┌─────────┬────┬──────────┐
-│ (index) │ 0  │  Values  │
+│ (index) │ 0  │ Values   │
 ├─────────┼────┼──────────┤
-│    a    │    │    1     │
-│    b    │    │ Symbol() │
-│    c    │ 10 │          │
+│ a       │    │ 1        │
+│ b       │    │ Symbol() │
+│ c       │ 10 │          │
 └─────────┴────┴──────────┘
 `);
 
 test(new Map([ ['a', 1], [Symbol(), [2]] ]), `
 ┌───────────────────┬──────────┬────────┐
-│ (iteration index) │   Key    │ Values │
+│ (iteration index) │ Key      │ Values │
 ├───────────────────┼──────────┼────────┤
-│         0         │   'a'    │   1    │
-│         1         │ Symbol() │ [ 2 ]  │
+│ 0                 │ 'a'      │ 1      │
+│ 1                 │ Symbol() │ [ 2 ]  │
 └───────────────────┴──────────┴────────┘
 `);
 
 test(new Set([1, 2, Symbol()]), `
 ┌───────────────────┬──────────┐
-│ (iteration index) │  Values  │
+│ (iteration index) │ Values   │
 ├───────────────────┼──────────┤
-│         0         │    1     │
-│         1         │    2     │
-│         2         │ Symbol() │
+│ 0                 │ 1        │
+│ 1                 │ 2        │
+│ 2                 │ Symbol() │
 └───────────────────┴──────────┘
 `);
 
 test({ a: 1, b: 2 }, ['a'], `
 ┌─────────┬───┐
 │ (index) │ a │
 ├─────────┼───┤
-│    a    │   │
-│    b    │   │
+│ a       │   │
+│ b       │   │
 └─────────┴───┘
 `);
 
 test([{ a: 1, b: 2 }, { a: 3, c: 4 }], ['a'], `
 ┌─────────┬───┐
 │ (index) │ a │
 ├─────────┼───┤
-│    0    │ 1 │
-│    1    │ 3 │
+│ 0       │ 1 │
+│ 1       │ 3 │
 └─────────┴───┘
 `);
 
 test(new Map([[1, 1], [2, 2], [3, 3]]).entries(), `
 ┌───────────────────┬─────┬────────┐
 │ (iteration index) │ Key │ Values │
 ├───────────────────┼─────┼────────┤
-│         0         │  1  │   1    │
-│         1         │  2  │   2    │
-│         2         │  3  │   3    │
+│ 0                 │ 1   │ 1      │
+│ 1                 │ 2   │ 2      │
+│ 2                 │ 3   │ 3      │
 └───────────────────┴─────┴────────┘
 `);
 
 test(new Map([[1, 1], [2, 2], [3, 3]]).values(), `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
-│         0         │   1    │
-│         1         │   2    │
-│         2         │   3    │
+│ 0                 │ 1      │
+│ 1                 │ 2      │
+│ 2                 │ 3      │
 └───────────────────┴────────┘
 `);
 
 test(new Map([[1, 1], [2, 2], [3, 3]]).keys(), `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
-│         0         │   1    │
-│         1         │   2    │
-│         2         │   3    │
+│ 0                 │ 1      │
+│ 1                 │ 2      │
+│ 2                 │ 3      │
 └───────────────────┴────────┘
 `);
 
 test(new Set([1, 2, 3]).values(), `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
 ├───────────────────┼────────┤
-│         0         │   1    │
-│         1         │   2    │
-│         2         │   3    │
+│ 0                 │ 1      │
+│ 1                 │ 2      │
+│ 2                 │ 3      │
 └───────────────────┴────────┘
 `);
 
@@ -164,61 +164,61 @@ test({ a: { a: 1, b: 2, c: 3 } }, `
 ┌─────────┬───┬───┬───┐
 │ (index) │ a │ b │ c │
 ├─────────┼───┼───┼───┤
-│    a    │ 1 │ 2 │ 3 │
+│ a       │ 1 │ 2 │ 3 │
 └─────────┴───┴───┴───┘
 `);
 
 test({ a: { a: { a: 1, b: 2, c: 3 } } }, `
 ┌─────────┬──────────┐
-│ (index) │    a     │
+│ (index) │ a        │
 ├─────────┼──────────┤
-│    a    │ [Object] │
+│ a       │ [Object] │
 └─────────┴──────────┘
 `);
 
 test({ a: [1, 2] }, `
 ┌─────────┬───┬───┐
 │ (index) │ 0 │ 1 │
 ├─────────┼───┼───┤
-│    a    │ 1 │ 2 │
+│ a       │ 1 │ 2 │
 └─────────┴───┴───┘
 `);
 
 test({ a: [1, 2, 3, 4, 5], b: 5, c: { e: 5 } }, `
 ┌─────────┬───┬───┬───┬───┬───┬───┬────────┐
 │ (index) │ 0 │ 1 │ 2 │ 3 │ 4 │ e │ Values │
 ├─────────┼───┼───┼───┼───┼───┼───┼────────┤
-│    a    │ 1 │ 2 │ 3 │ 4 │ 5 │   │        │
-│    b    │   │   │   │   │   │   │   5    │
-│    c    │   │   │   │   │   │ 5 │        │
+│ a       │ 1 │ 2 │ 3 │ 4 │ 5 │   │        │
+│ b       │   │   │   │   │   │   │ 5      │
+│ c       │   │   │   │   │   │ 5 │        │
 └─────────┴───┴───┴───┴───┴───┴───┴────────┘
 `);
 
 test(new Uint8Array([1, 2, 3]), `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
-│    0    │   1    │
-│    1    │   2    │
-│    2    │   3    │
+│ 0       │ 1      │
+│ 1       │ 2      │
+│ 2       │ 3      │
 └─────────┴────────┘
 `);
 
 test(Buffer.from([1, 2, 3]), `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
-│    0    │   1    │
-│    1    │   2    │
-│    2    │   3    │
+│ 0       │ 1      │
+│ 1       │ 2      │
+│ 2       │ 3      │
 └─────────┴────────┘
 `);
 
 test({ a: undefined }, ['x'], `
 ┌─────────┬───┐
 │ (index) │ x │
 ├─────────┼───┤
-│    a    │   │
+│ a       │   │
 └─────────┴───┘
 `);
 
@@ -238,23 +238,23 @@ test(new Map(), `
 
 test([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], `
 ┌─────────┬─────┬─────┐
-│ (index) │  a  │  b  │
+│ (index) │ a   │ b   │
 ├─────────┼─────┼─────┤
-│    0    │  1  │ 'Y' │
-│    1    │ 'Z' │  2  │
+│ 0       │ 1   │ 'Y' │
+│ 1       │ 'Z' │ 2   │
 └─────────┴─────┴─────┘
 `);
 
 {
   const line = '─'.repeat(79);
-  const header = `${' '.repeat(37)}name${' '.repeat(40)}`;
+  const header = `name${' '.repeat(77)}`;
   const name = 'very long long long long long long long long long long long ' +
                'long long long long';
   test([{ name }], `
 ┌─────────┬──${line}──┐
-│ (index) │  ${header}│
+│ (index) │ ${header} │
 ├─────────┼──${line}──┤
-│    0    │ '${name}' │
+│ 0       │ '${name}' │
 └─────────┴──${line}──┘
 `);
 }
@@ -263,17 +263,17 @@ test({ foo: '￥', bar: '¥' }, `
 ┌─────────┬────────┐
 │ (index) │ Values │
 ├─────────┼────────┤
-│   foo   │  '￥'  │
-│   bar   │  '¥'   │
+│ foo     │ '￥'   │
+│ bar     │ '¥'    │
 └─────────┴────────┘
 `);
 
 test({ foo: '你好', bar: 'hello' }, `
 ┌─────────┬─────────┐
 │ (index) │ Values  │
 ├─────────┼─────────┤
-│   foo   │ '你好'  │
-│   bar   │ 'hello' │
+│ foo     │ '你好'  │
+│ bar     │ 'hello' │
 └─────────┴─────────┘
 `);
 
@@ -285,8 +285,8 @@ test([{ foo: 10 }, { foo: 20 }], ['__proto__'], `
 ┌─────────┬───────────┐
 │ (index) │ __proto__ │
 ├─────────┼───────────┤
-│    0    │           │
-│    1    │           │
+│ 0       │           │
+│ 1       │           │
 └─────────┴───────────┘
 `);
 assert.strictEqual('0' in Object.prototype, false);