pretty-inspect.js

README.md

pretty printer for object/arrays

const result = inspect([ { index: 1,   value: 'foo bar baz '.repeat(100) },
                         { index: 2,   value: 'foo bar baz '.repeat(10)  },
                         { index: 125, value:  null                      },
                         { index: 16,  value: 0123456789                 },
                         { index: 300, value: function foo() {}          },
                         { index: 8,   value: 'blablablabla'             }
                         ], {  headers: ['index', 'value'], maxrows: 5, padding: 2 })
                         // assume + 100 items

console.log(result)

objects

import { inspect } from './pretty-layout.js'

const result = inspect({
  foo: 'bar',
  bar: 'baz',
  quux: 1010,
  quuz: 199203,
  corge: null
}, {  headers: ['prop', 'value'], maxrows: 4, padding: 1 })

• Everything is dimmed, except the values,
  which are colorized according to their type using util.inspect

• I wrote this a pretty opinter for displaying custom errors in a test runner. The dimming is functional, not decorative, because test runners
  spit out a lot of errors which can quickly become distracting.

• it's self-balancing which means if the index value is a-gazillion-bazillion
  it auto-adjusts so it doesn't look messed up

  points:

  • no deps, ~ 50 lines.
  • follows NO_COLOR.
  • not a console.table equivalent; only prints 2 columns.
  • no perf. opts, there's multiple O^who knows loops going on but its fine for us.

test

copy/paste the unit test file below, and run it with node --test.

requires node v22+

• some generic unit-tests
• missing object tests

authors

nicholaswmin, published with MIT License

pretty-inspect.js

import { styleText, inspect as _inspect } from 'node:util'

const { NODE_ENV, NODE_TEST_CONTEXT } = process.env, 
        ENV_TEST =!!NODE_TEST_CONTEXT || NODE_ENV?.includes('test'),
        CAN_COLOR = process.stdout?.hasColors?.() || ENV_TEST

export const inspect = (arr, { 
  headers = ['index', 'value'],
  maxrows = 10, padding = 1, 
  vspacer = `\n`.repeat(padding)
} = {}) => {
  arr = Array.isArray(arr) ? arr : Object.entries(arr).map(toIterableShape)

  const table = [
    { index: headers[0],  value: headers[1] },  
    ...arr
    ].slice(0, maxrows + 1)
     .reduce(toTable, '')
    
  return `${vspacer}${table}`
         + `${toHiddenRowLabel(arr.length - maxrows + 1)}`
         + `${vspacer}`
}

export const toColoredFunction = ([name, ...args], i, arr) => {
  const dimExceptLast = (value, j) => i === arr.length - 1 && j === 3
    ? color('red', value) : muted(value)
  
  return ['.', name, '(', args.toString(), ')'].map(dimExceptLast).join('')
}

const muted = value => CAN_COLOR ? styleText(['dim'], value) : value
const reset = value => styleText(['reset'], value)
const color = (color, value) => CAN_COLOR ? styleText([color], value) : value
const formt = (value, maxlength = 20) => {
  const fmt = _inspect(value, { colors: CAN_COLOR })

  return CAN_COLOR 
    ? fmt.slice(0, maxlength) + (fmt.length > maxlength ? muted('...') : '')
    : value
}

const toIterableShape = ([index, value]) => ({ index: index, value })
const toHiddenRowLabel = num => num > 0 ? muted(`\n (${num} hidden)\n\n`) : ''

const toTable = (acc, entry, i, arr) => {
  const index = Array.isArray(entry) ? entry[0]: entry.index
  const value = Array.isArray(entry) ? entry[1] : entry.value

  const key = Object.fromEntries(['-','-','|'].map(x => [x, muted(x)]))
  const idx = String(index), val = String(value),

    margins = [
      Math.max(...arr.map(({ index }) => String(index).length)) + 2,
      Math.max(...arr.map(({ value }) => String(value).length)) + 1
    ], 
    padding = [idx.padStart(margins[0], ' '), value ], 
    borders = [ 
      key['-'].repeat(padding[0].length + 1),
      key['-'].repeat(padding[0].length)
    ],
    headers = `${borders[0]}${key['-']}${borders[1]}`,
    formatted = {
      index: i >= 0 ? muted(padding[0]) : padding[0],
      value: i > 0  ? reset(formt(padding[1])) : muted(padding[1])
    }
    a
    return i === 1 
      ? acc += `${headers}\n${formatted.index} ${key['|']} ${formatted.value}\n` 
      : acc += `${formatted.index} ${key['|']} ${formatted.value}\n`
}

pretty-layout.test.js

/* 
Unit-tests    
Requires node v22.5+  
- [ ] missing object tests
*/

import test from 'node:test'
import { inspect } from './pretty-layout.js'
import { stripVTControlCharacters } from 'node:util'

const is = { 
  dash: { get vert() { return '|' } },
  separators: { 
    vert: c => c === is.dash.vert 
  }, exists: i => i > -1
}

test('#inspect(array)', async t => {  
  const res = inspect([
    { index: 1,  value: 'foobar'.repeat(100)      },
    { index: 2,  value: 'bar'                     },
    { index: 4,  value:  null                     },
    { index: 16, value: 3920392                   },
    { index: 4992991, value: function foobar() {} },
    { index: 8,  value: 1000                      }
  ], {  headers: ['index', 'value'], maxrows: 5, padding: 2 }),
    lines = res.split('\n')
      .map(stripVTControlCharacters)
      .filter(Boolean)

  await t.test('returns a result', t => {
    t.assert.ok(res)
  })

  await t.test('is a string', async t => {
    t.assert.strictEqual(typeof res, 'string')

    await t.test('with 8 lines', t => {
      t.assert.strictEqual(lines.length, 8)
    })
    
    await t.test('1st line contains a header', async t => {
      const cols = lines[0].split(is.dash.vert)

      await t.test('has 2 columns', async t => {
        const cols = lines[0].split(is.dash.vert)
  
        t.assert.strictEqual(cols.length, 2)
      })
      
      await t.test('column 1 contains column 1 header', async t => {  
        t.assert.ok(cols[0].includes('index'))
      })
      
      await t.test('column 2 contains column 2 header', async t => {
        t.assert.ok(cols[1].includes('value'))
      })
    })

    await t.test('2nd line contains a border', async t => {
      const horizontalchars = lines[1].split('-')

      await t.test('contains only dashes', t => {
        t.assert.ok(lines[1].split('').every(c => '-'))
      })

      await t.test('is of reasonable length', t => {
        t.assert.ok(horizontalchars.length > 15)
        t.assert.ok(horizontalchars.length < 25)
      })
    })
    
    await t.test('3rd line contains the first row', async t => {
      const columns = { 
        left: lines[2].split(is.dash.vert)[0], 
        right: lines[2].split(is.dash.vert)[1] }

      t.assert.ok(columns.left.includes('1'))
      t.assert.ok(columns.right.includes('foobar'))

      await t.test('left column contains the index', t => {
        t.assert.ok(columns.left.includes('1'))
      })
      
      await t.test('right column contains the value', t => {
        t.assert.ok(columns.right.includes('foobar'))
      })

      await t.test('value is clipped when too long', t => {
        t.assert.ok(columns.right.endsWith('...'))
        t.assert.ok(columns.right.length < 35)
      })
    })
    
    await t.test('is vertically aligned', t => {
      const pipeOffsets = {
        ['1']: lines[0].split('').findIndex(is.separators.vert),
        ['*']: lines.map(line => line.split('')
          .findIndex(is.separators.vert))
          .filter(is.exists)
      }

      t.assert.ok(pipeOffsets['*'].length > 3)
      t.assert.ok(pipeOffsets['*'].every(is.exists))
      t.assert.ok(pipeOffsets['*'].every(pos => pos === pipeOffsets[1]))
    })
    
    await t.test('is horizontally aligned', async t => {
      const offsets = {
        left: lines[0].split(is.dash.vert)[0].split('index')[1].length,
        right: lines[0].split(is.dash.vert)[1].split('value')[0].length
      }

      await t.test('each header is equally distant from center', t => {
        t.assert.strictEqual(offsets.left, offsets.right) 
      })
      
      await t.test('each row is equally distant from center', t => {
        const hasChar = c => !!c.trim()
        const offsets = lines.slice(2, 7).filter(Boolean).map(l => ({
          left: l.split(is.dash.vert)[0].split('').reverse().findIndex(hasChar),
          right: l.split(is.dash.vert)[1]?.split('').findIndex(hasChar)
        }))
        
        t.assert.ok(offsets.every(o => o.left === offsets[0].left))
        t.assert.ok(offsets.every(o => o.right === offsets[0].right))
      })
    })
    
    await t.test('has a label displaying hidden items count', async t => {
      const label = lines.filter(line => line.includes('hidden'))
      t.assert.strictEqual(label.length, 1)
      
      await t.test('stating the correct hidden count', t => {
        t.assert.ok(label[0].includes('2'))
      })
    })
  })
})