console-toolkit 1.0.0 → 1.1.1

package/README.md

@@ -89,4 +89,6 @@ BSD 3-Clause License
 
 ## Release history
 
+- 1.1.1: *Minor bugfixes in `Table`, some improvements, updated deps.*
+- 1.1.0: *Minor improvements, enhanced `Writer` and `Updater`.*
 - 1.0.0: *Initial release.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "console-toolkit",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Toolkit to produce a fancy console output (boxes, tables, charts, colors).",
   "type": "module",
   "main": "src/index.js",
@@ -54,6 +54,6 @@
     ]
   },
   "devDependencies": {
-    "tape-six": "^0.9.3"
+    "tape-six": "^0.9.6"
   }
 }

package/src/alphanumeric/number-formatters.js

@@ -24,7 +24,7 @@ export const prepareTimeFormat = (values, scale = 1, useUnicode) => {
 
 export const formatTime = (value, format) => {
   let result = (value * format.scale).toFixed(format.precision);
-  if (format.precision > 0) result = result.replace(/\.0+$/, '');
+  if (format.precision > 0 && !format.keepFractionAsIs) result = result.replace(/\.0+$/, '');
   return result + format.unit;
 };
 
@@ -111,7 +111,7 @@ export const compareDifference = (a, b) => {
   if (diff === Infinity) return {less, infinity: true};
 
   if (diff < 2) {
-    const percentage = diff * 100;
+    const percentage = absDiff / (less ? a : b) * 100;
     if (percentage < 0.001) return {less, equality: true};
     if (percentage < 1) return {less, percentage: formatNumber(percentage, {decimals: 3})};
     if (percentage < 10) return {less, percentage: formatNumber(percentage, {decimals: 2})};

package/src/output/updater.js

@@ -7,11 +7,15 @@ import {cursorUp, setCommands} from '../ansi/csi.js';
 const RESET = setCommands([]);
 
 export class Updater {
-  constructor(updater, {prologue, epilogue, noLastNewLine} = {}, writer = new Writer()) {
+  constructor(updater, {prologue, epilogue, beforeFrame, afterFrame, beforeLine, afterLine, noLastNewLine} = {}, writer = new Writer()) {
     this.updater = updater;
     this.writer = writer;
     this.prologue = prologue || RESET;
     this.epilogue = epilogue || RESET;
+    this.beforeFrame = beforeFrame || '';
+    this.afterFrame = afterFrame || '';
+    this.beforeLine = beforeLine || '';
+    this.afterLine = afterLine || '';
     this.noLastNewLine = noLastNewLine;
     this.lastHeight = 0;
     this.isDone = false;
@@ -34,30 +38,31 @@ export class Updater {
     this.intervalHandle = null;
   }
 
-  getFrame(state) {
-    if (typeof this.updater == 'function') return this.updater(state);
+  getFrame(state, ...args) {
+    if (typeof this.updater == 'function') return this.updater(state, ...args);
     if (typeof this.updater?.getFrame == 'function') {
       this.updater.state = state;
-      return this.updater.getFrame();
+      return this.updater.getFrame(...args);
     }
     throw new TypeError('Updater must be a function or implement getFrame()');
   }
 
-  async writeFrame(state) {
+  async writeFrame(state, ...args) {
     if (this.first) {
       this.prologue && (await this.writer.writeString(this.prologue));
       this.first = false;
     }
 
-    const frame = toStrings(this.getFrame(state));
+    const frame = toStrings(this.getFrame(state, ...args));
     if (!frame) return;
 
-    if (this.lastHeight) await this.writer.writeString('\r' + cursorUp(this.lastHeight));
+    if (this.lastHeight) await this.writer.writeString('\r' + cursorUp(this.lastHeight) + this.beforeFrame);
 
     this.lastHeight = frame.length;
     if (this.noLastNewLine) --this.lastHeight;
 
-    await this.writer.write(frame, false, this.noLastNewLine);
+    await this.writer.write(frame, {noLastNewLine: this.noLastNewLine, beforeLine: this.beforeLine, afterLine: this.afterLine});
+    this.afterFrame && (await this.writer.writeString(this.afterFrame));
   }
 
   async done() {
@@ -67,14 +72,14 @@ export class Updater {
     this.epilogue && (await this.writer.writeString(this.epilogue));
   }
 
-  async update(state = 'active') {
+  async update(state = 'active', ...args) {
     if (this.isDone || !this.writer.isTTY) return;
-    await this.writeFrame(state);
+    await this.writeFrame(state, ...args);
   }
 
-  async final() {
+  async final(...args) {
     if (this.isDone) return;
-    await this.writeFrame('finished');
+    await this.writeFrame('finished', ...args);
     await this.done();
   }
 }

package/src/output/writer.js

@@ -93,12 +93,12 @@ export class Writer {
     await write(this.stream, s.replace(matchCsiNoGroups, ''));
   }
 
-  async write(s, sameColumn, noLastNewLine) {
+  async write(s, {sameColumn, noLastNewLine, beforeLine = '', afterLine = ''} = {}) {
     s = toStrings(s);
 
     if (!this.isTTY) {
       const matcher = this.forceColorDepth ? matchCsiNoSgrNoGroups : matchCsiNoGroups;
-      let lines = Array.from(s).join('\n');
+      let lines = Array.from(s).map(line => beforeLine + line + afterLine).join('\n');
       if (!noLastNewLine) lines += '\n';
       matcher.lastIndex = 0;
       lines = lines.replace(matcher, '');
@@ -108,21 +108,22 @@ export class Writer {
 
     if (sameColumn === 'save') {
       for (const line of s) {
-        await write(this.stream, CURSOR_SAVE_POS + line + CURSOR_RESTORE_POS + CURSOR_DOWN1);
+        await write(this.stream, CURSOR_SAVE_POS + beforeLine + line + afterline + CURSOR_RESTORE_POS + CURSOR_DOWN1);
       }
       return;
     }
 
     if (sameColumn) {
       for (const line of s) {
-        const length = getLength(line);
-        await write(this.stream, line);
+        const fullLine = beforeLine + line + afterLine,
+          length = getLength(fullLine);
+        await write(this.stream, fullLine);
         await this.moveCursor(-length, 1);
       }
       return;
     }
 
-    let lines = Array.from(s).join('\n');
+    let lines = Array.from(s).map(line => beforeLine + line + afterLine).join('\n');
     if (!noLastNewLine) lines += '\n';
     await write(this.stream, lines);
   }

package/src/table/table.js

@@ -7,17 +7,20 @@ const getCellAlign = (align, index) => (typeof align == 'string' && align[index]
 
 const ensureSize = (cellSize, cellLength, cellGap, pos, lineTheme, axis, lengths) => {
   let available = (cellSize - 1) * cellGap;
-  for (let i = 0; i < cellSize; ++i)
-    available += lengths[pos + i] + (!axis[pos + i] ? 0 : lineTheme ? lineTheme['w_' + axis[pos + i]] : 1);
+  for (let i = 0; i < cellSize; ++i) {
+    available += lengths[pos + i];
+    if (i + 1 === cellSize || !axis[pos + i]) continue;
+    available += lineTheme ? lineTheme['w_' + axis[pos + i]] : 1;
+  }
   if (cellLength > available) {
     const diff = cellLength - available,
       perCell = Math.floor(diff / cellSize),
       remainder = diff % cellSize;
     if (perCell) {
-      for (let i = 0; i < cellSize; ++i) lengths[j + i] += perCell;
+      for (let i = 0; i < cellSize; ++i) lengths[pos + i] += perCell;
     }
     if (remainder) {
-      for (let i = 0; i < remainder; ++i) ++lengths[j + i];
+      for (let i = 0; i < remainder; ++i) ++lengths[pos + i];
     }
   }
 };