bare-console 6.1.0 → 6.2.0

package/README.md

@@ -23,6 +23,92 @@ console.timeEnd()
 console.trace('Show me')
 ```
 
+To install `console` as a global, require the `bare-console/global` subpath:
+
+```js
+require('bare-console/global')
+
+console.log('Hello')
+```
+
+## API
+
+#### `const console = new Console([log])`
+
+Construct a new `Console`. By default, output is written through `bare-logger` (<https://github.com/holepunchto/bare-logger>), or `bare-system-logger` (<https://github.com/holepunchto/bare-system-logger>) on Android.
+
+Pass a custom `log` object to redirect output:
+
+```js
+const Console = require('bare-console')
+const FileLog = require('bare-file-logger')
+
+const console = new Console(new FileLog('my-logs.txt'))
+```
+
+The `log` object implements the methods used by the console operations being called:
+
+```js
+log = {
+  debug(...data),
+  info(...data),
+  warn(...data),
+  error(...data),
+  clear(),
+  format(...data)
+}
+```
+
+A minimal backend only needs the subset it intends to support; for example, `info` is sufficient for `console.log()`.
+
+#### `console.log(...data)`
+
+#### `console.info(...data)`
+
+#### `console.debug(...data)`
+
+#### `console.warn(...data)`
+
+#### `console.error(...data)`
+
+Forward `data` to the corresponding method on the backend. `console.log()` is an alias for `console.info()`.
+
+#### `console.clear()`
+
+Forward to `log.clear()`.
+
+#### `console.time([label])`
+
+Start a timer identified by `label` (default `'default'`). Warns if a timer with the same label is already running.
+
+#### `console.timeLog([label[, ...data]])`
+
+Log the elapsed time for the timer identified by `label` (default `'default'`), along with any additional `data`. Output uses milliseconds for short durations and seconds beyond one second.
+
+#### `console.timeEnd([label])`
+
+Log the elapsed time and remove the timer identified by `label` (default `'default'`).
+
+#### `console.count([label])`
+
+Increment and log the counter identified by `label` (default `'default'`).
+
+#### `console.countReset([label])`
+
+Remove the counter identified by `label` (default `'default'`).
+
+#### `console.trace(...data)`
+
+Log a stack trace prefixed with the formatted `data`.
+
+#### `console.assert(condition, ...data)`
+
+If `condition` is falsy, log `data` prefixed with `'Assertion failed'`. Otherwise do nothing.
+
+#### `console.table(tabularData[, properties])`
+
+Render `tabularData` as a table. Arrays and plain objects use an `(index)` column; `Map` and `Set` use an `(iteration index)` column with `key` and `values` (or `values` only) headers. Pass `properties` to restrict which object keys are shown as columns; the argument is ignored for `Map` and `Set`. Values that aren't tabular (primitives, `null`, functions) fall back to `console.log(tabularData)`.
+
 ## License
 
 Apache-2.0

package/index.d.ts

@@ -19,6 +19,7 @@ interface Console {
   count(label?: string): void
   countReset(label?: string): void
   trace(...data: unknown[]): void
+  table(tabularData: unknown, properties?: readonly string[]): void
 }
 
 declare class Console {

package/index.js

@@ -1,6 +1,7 @@
 const Log = require('bare-logger')
 const SystemLog = require('bare-system-logger')
 const hrtime = require('bare-hrtime')
+const formatTable = require('./lib/table')
 
 module.exports = exports = class Console {
   constructor(log = defaultLog()) {
@@ -107,6 +108,13 @@ module.exports = exports = class Console {
 
       this.error(...data)
     }
+
+    // https://console.spec.whatwg.org/#table
+    this.table = function table(tabularData, properties) {
+      const formatted = formatTable(tabularData, properties, (value) => log.format('%o', value))
+
+      this.log(formatted !== null ? formatted : tabularData)
+    }
   }
 
   // For Node.js compatibility

package/lib/table.js

@@ -0,0 +1,165 @@
+const type = require('bare-type')
+
+module.exports = function formatTable(tabularData, properties, format) {
+  if (properties !== undefined && !Array.isArray(properties)) {
+    throw new TypeError("The 'properties' argument must be an array")
+  }
+
+  if (tabularData === null || typeof tabularData !== 'object') return null
+
+  const formatCell = (value) => format(value).replace(/\r\n|\r|\n/g, '\\n')
+
+  const t = type(tabularData)
+
+  if (t.isMap()) return renderMap(tabularData, formatCell)
+  if (t.isSet()) return renderSet(tabularData, formatCell)
+
+  const indices = Object.keys(tabularData)
+
+  if (indices.length === 0) return render(['(index)'], [])
+
+  const columns = properties !== undefined ? [...properties] : []
+  let hasValues = false
+
+  for (const index of indices) {
+    const value = tabularData[index]
+
+    if (value === null || typeof value !== 'object') {
+      hasValues = true
+      continue
+    }
+
+    if (properties === undefined) {
+      for (const key of Object.keys(value)) {
+        if (!columns.includes(key)) columns.push(key)
+      }
+    }
+  }
+
+  const header = ['(index)', ...columns]
+  if (hasValues) header.push('values')
+
+  const rows = indices.map((index) => {
+    const value = tabularData[index]
+    const row = new Array(header.length).fill('')
+
+    row[0] = index
+
+    if (value !== null && typeof value === 'object') {
+      for (let i = 0; i < columns.length; i++) {
+        if (Object.hasOwn(value, columns[i])) {
+          row[i + 1] = formatCell(value[columns[i]])
+        }
+      }
+    } else if (hasValues) {
+      row[header.length - 1] = formatCell(value)
+    }
+
+    return row
+  })
+
+  return render(header, rows)
+}
+
+function renderMap(map, formatCell) {
+  const header = ['(iteration index)', 'key', 'values']
+  const rows = []
+
+  let i = 0
+  for (const [key, value] of map) {
+    rows.push([String(i++), formatCell(key), formatCell(value)])
+  }
+
+  return render(header, rows)
+}
+
+function renderSet(set, formatCell) {
+  const header = ['(iteration index)', 'values']
+  const rows = []
+
+  let i = 0
+  for (const value of set) {
+    rows.push([String(i++), formatCell(value)])
+  }
+
+  return render(header, rows)
+}
+
+function render(header, rows) {
+  const widths = header.map((h, i) => {
+    let max = stringWidth(h)
+    for (const r of rows) max = Math.max(max, stringWidth(r[i]))
+    return max
+  })
+
+  const border = (l, m, r) => l + widths.map((w) => '─'.repeat(w + 2)).join(m) + r
+
+  const row = (cells) =>
+    '│' + cells.map((c, i) => ` ${c}${' '.repeat(widths[i] - stringWidth(c))} `).join('│') + '│'
+
+  return [
+    border('┌', '┬', '┐'),
+    row(header),
+    border('├', '┼', '┤'),
+    ...rows.map(row),
+    border('└', '┴', '┘')
+  ].join('\n')
+}
+
+const ansi = /\x1b\[[\d;?]*[a-zA-Z]/g
+
+function stringWidth(str) {
+  str = str.replace(ansi, '')
+
+  let width = 0
+
+  for (const char of str) {
+    const code = char.codePointAt(0)
+
+    if (isFullWidthCodePoint(code)) width += 2
+    else if (!isZeroWidthCodePoint(code)) width += 1
+  }
+
+  return width
+}
+
+function isFullWidthCodePoint(code) {
+  return (
+    code >= 0x1100 &&
+    (code <= 0x115f ||
+      code === 0x2329 ||
+      code === 0x232a ||
+      (code >= 0x2e80 && code <= 0x3247 && code !== 0x303f) ||
+      (code >= 0x3250 && code <= 0x4dbf) ||
+      (code >= 0x4e00 && code <= 0xa4c6) ||
+      (code >= 0xa960 && code <= 0xa97c) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe10 && code <= 0xfe19) ||
+      (code >= 0xfe30 && code <= 0xfe6b) ||
+      (code >= 0xff01 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6) ||
+      (code >= 0x1b000 && code <= 0x1b001) ||
+      (code >= 0x1f200 && code <= 0x1f251) ||
+      (code >= 0x1f300 && code <= 0x1f64f) ||
+      (code >= 0x1f680 && code <= 0x1f6ff) ||
+      (code >= 0x1f900 && code <= 0x1f9ff) ||
+      (code >= 0x1fa70 && code <= 0x1faff) ||
+      (code >= 0x20000 && code <= 0x3fffd))
+  )
+}
+
+function isZeroWidthCodePoint(code) {
+  return (
+    code <= 0x1f ||
+    (code >= 0x7f && code <= 0x9f) ||
+    (code >= 0x300 && code <= 0x36f) ||
+    (code >= 0x200b && code <= 0x200f) ||
+    (code >= 0x20d0 && code <= 0x20ff) ||
+    (code >= 0xfe00 && code <= 0xfe0f) ||
+    (code >= 0xfe20 && code <= 0xfe2f) ||
+    code === 0x200d ||
+    (code >= 0xfff9 && code <= 0xfffb) ||
+    (code >= 0xe0100 && code <= 0xe01ef)
+  )
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-console",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "WHATWG debugging console for JavaScript",
   "exports": {
     "./package": "./package.json",
@@ -17,10 +17,13 @@
     "index.js",
     "index.d.ts",
     "global.js",
-    "global.d.ts"
+    "global.d.ts",
+    "lib"
   ],
   "scripts": {
-    "test": "prettier . --check && bare test.js"
+    "format": "prettier --write . && lunte --fix",
+    "lint": "prettier --check . && lunte",
+    "test": "brittle-bare --coverage test.js"
   },
   "repository": {
     "type": "git",
@@ -33,12 +36,15 @@
   },
   "homepage": "https://github.com/holepunchto/bare-console#readme",
   "dependencies": {
+    "bare-format": "^1.0.2",
     "bare-hrtime": "^2.0.0",
     "bare-logger": "^2.0.0",
-    "bare-system-logger": "^1.0.2"
+    "bare-system-logger": "^1.0.2",
+    "bare-type": "^1.1.0"
   },
   "devDependencies": {
     "brittle": "^3.1.1",
+    "lunte": "^1.8.0",
     "prettier": "^3.3.3",
     "prettier-config-holepunch": "^2.0.0"
   }