Add beautiful-error

Author: ehmicky

src/exit.js

@@ -1,6 +1,5 @@
 import process from 'node:process'
 
-import { handleInvalidOpts } from './options/invalid.js'
 import { waitForTimeout } from './timeout.js'
 
 // Validate `exitCode` option
@@ -10,10 +9,8 @@ export const validateExitCode = (exitCode, optName) => {
     exitCode < MIN_EXIT_CODE ||
     exitCode > MAX_EXIT_CODE
   ) {
-    handleInvalidOpts(
-      `must be between ${MIN_EXIT_CODE} and ${MAX_EXIT_CODE}`,
-      exitCode,
-      optName,
+    throw new Error(
+      `"${optName}" must be between ${MIN_EXIT_CODE} and ${MAX_EXIT_CODE}: ${exitCode}`,
     )
   }
 }

src/main.js

@@ -1,8 +1,8 @@
+import beautifulError from 'beautiful-error'
 import normalizeException from 'normalize-exception'
 
 import { exitProcess } from './exit.js'
 import { getOpts } from './options/main.js'
-import { printError } from './print/main.js'
 
 export { validateOptions } from './options/validate.js'
 
@@ -11,10 +11,25 @@ const handleCliError = (error, opts) => {
   const errorA = normalizeException(error)
   const {
     error: errorB,
-    opts: { silent, stack, props, colors, icon, header, exitCode, timeout },
-  } = getOpts(opts, errorA)
-  printError({ error: errorB, silent, stack, props, colors, icon, header })
+    opts: { silent, exitCode, timeout },
+    beautifulErrorOpts,
+  } = getOpts(errorA, opts)
+
+  printError(errorB, silent, beautifulErrorOpts)
   exitProcess(exitCode, timeout)
 }
 
+// We pass the `error` instance to `console.error()`, so it prints not only its
+// `message` and `stack` but also its properties, `cause`, aggregate `errors`,
+// add colors, inline preview, etc. using `util.inspect()`
+const printError = (error, silent, beautifulErrorOpts) => {
+  if (silent) {
+    return
+  }
+
+  const errorString = beautifulError(error, beautifulErrorOpts)
+  // eslint-disable-next-line no-restricted-globals, no-console
+  console.error(errorString)
+}
+
 export default handleCliError

src/main.test.js

@@ -4,6 +4,8 @@ import { each } from 'test-each'
 
 import { handleError } from './helpers/main.test.js'
 
+const testError = new TypeError('test')
+
 each(
   [
     { error: undefined, expectedMessage: 'Error: undefined' },
@@ -26,3 +28,8 @@ test.serial('validateOpts() throws on invalid options', (t) => {
 test.serial('validateOpts() does not throw on valid options', (t) => {
   t.notThrows(validateOptions.bind(undefined, { silent: true }))
 })
+
+test.serial('Does not log if "silent" is true', (t) => {
+  const { consoleArg } = handleError(testError, { silent: true })
+  t.is(consoleArg, undefined)
+})

src/options/classes.js

@@ -1,26 +1,25 @@
 import isPlainObj from 'is-plain-obj'
 
 import { removeUndefined } from './default.js'
-import { handleInvalidOpts } from './invalid.js'
 
-// Validate `classes` option
-export const validateClasses = (classes, optName, validateAllOpts) => {
-  if (!isPlainObj(classes)) {
-    handleInvalidOpts('must be a plain object', classes, optName)
+// `options.classes.{ErrorName}.*` is like `options.*` but only applies if
+// `error.name` matches.
+export const applyClassesOpts = ({ name }, opts = {}) => {
+  if (!isPlainObj(opts)) {
+    throw new Error(`options must be a plain object: ${opts}`)
   }
 
-  if (optName.length > 1) {
-    handleInvalidOpts('must not be defined', classes, optName)
-  }
+  const { classes = {}, ...optsA } = opts
+  validateObject(classes, 'classes')
+
+  const classesOpts = classes[name] || classes.default || {}
+  validateObject(classesOpts, `classes.${name}`)
 
-  Object.entries(classes).forEach(([className, classOpts]) => {
-    validateAllOpts(classOpts, [...optName, className])
-  })
+  return { ...optsA, ...removeUndefined(classesOpts) }
 }
 
-// `options.classes.{ErrorName}.*` is like `options.*` but only applies if
-// `error.name` matches.
-export const applyClassesOpts = ({ name }, { classes = {}, ...opts } = {}) => {
-  const classesOpts = classes[name] || classes.default || {}
-  return { ...opts, ...removeUndefined(classesOpts) }
+const validateObject = (value, optName) => {
+  if (!isPlainObj(value)) {
+    throw new Error(`"${optName}" must be a plain object: ${value}`)
+  }
 }

src/options/default.js

@@ -12,10 +12,6 @@ export const applyDefaultOpts = (opts) => ({
 // Default values of options
 export const DEFAULT_OPTS = {
   silent: false,
-  stack: true,
-  props: true,
-  icon: 'cross',
-  header: 'red bold',
   exitCode: DEFAULT_EXIT_CODE,
   timeout: DEFAULT_TIMEOUT,
 }

src/options/invalid.js

@@ -2,27 +2,25 @@ import normalizeException from 'normalize-exception'
 
 import { INVALID_OPTS_EXIT_CODE } from '../exit.js'
 
-import { applyClassesOpts } from './classes.js'
 import { applyDefaultOpts, DEFAULT_OPTS } from './default.js'
-import { validateOptions } from './validate.js'
+import { normalizeOptions } from './validate.js'
 
 // Normalize and validate options
-export const getOpts = (opts, error) => {
+export const getOpts = (error, opts) => {
   try {
-    return safeGetOpts(opts, error)
+    return safeGetOpts(error, opts)
   } catch (error_) {
     // eslint-disable-next-line fp/no-mutation
     error_.message = `handle-cli-error invalid usage: ${error_.message}`
     const errorA = normalizeException(error_)
-    return { error: errorA, opts: INVALID_OPTS }
+    return { error: errorA, opts: INVALID_OPTS, beautifulErrorOpts: {} }
   }
 }
 
-const safeGetOpts = (opts, error) => {
-  validateOptions(opts)
-  const optsA = applyClassesOpts(error, opts)
+const safeGetOpts = (error, opts = {}) => {
+  const { opts: optsA, beautifulErrorOpts } = normalizeOptions(error.name, opts)
   const optsB = applyDefaultOpts(optsA)
-  return { error, opts: optsB }
+  return { error, opts: optsB, beautifulErrorOpts }
 }
 
 // Options used when invalid input is passed

src/options/main.js

@@ -1,62 +1,53 @@
+import { validateOptions as validateBeautifulOptions } from 'beautiful-error'
 import isPlainObj from 'is-plain-obj'
 
 import { validateExitCode } from '../exit.js'
 import { validateTimeout } from '../timeout.js'
 
-import { validateClasses } from './classes.js'
-import { handleInvalidOpts } from './invalid.js'
+import { applyClassesOpts } from './classes.js'
 
 // Validate option values.
 // This is exported, although not documented.
 export const validateOptions = (opts) => {
-  validateAllOpts(opts, [])
-}
-
-const validateAllOpts = (opts, optName) => {
-  if (opts === undefined) {
-    return
-  }
-
   if (!isPlainObj(opts)) {
-    handleInvalidOpts('must be a plain object', opts, optName)
+    return
   }
 
-  Object.entries(opts).forEach(([key, optValue]) => {
-    validateOpt(optValue, [...optName, key])
+  const { classes } = opts
+  const names =
+    isPlainObj(classes) && Object.keys(classes).length !== 0
+      ? Object.keys(classes)
+      : ['default']
+  names.forEach((name) => {
+    normalizeOptions(name, opts)
   })
 }
 
-const validateOpt = (optValue, optName) => {
-  if (optValue === undefined || BEAUTIFUL_ERROR_OPTS.has(optName)) {
-    return
-  }
-
-  const validator = VALIDATORS[optName.at(-1)]
+export const normalizeOptions = (name, opts) => {
+  const { silent, exitCode, timeout, ...beautifulErrorOpts } = applyClassesOpts(
+    name,
+    opts,
+  )
+  const optsA = { silent, exitCode, timeout }
+  Object.entries(optsA).forEach(validateOpt)
+  validateBeautifulOptions(beautifulErrorOpts)
+  return { opts: optsA, beautifulErrorOpts }
+}
 
-  if (validator === undefined) {
-    handleInvalidOpts('is an unknown option', '', optName)
+const validateOpt = ([optName, optValue]) => {
+  if (optValue !== undefined) {
+    VALIDATORS[optName](optValue, optName)
   }
-
-  validator(optValue, optName, validateAllOpts)
 }
 
 const validateBooleanOpt = (value, optName) => {
   if (typeof value !== 'boolean') {
-    handleInvalidOpts('must be a boolean', value, optName)
+    throw new TypeError(`"${optName}" must be a boolean: ${value}`)
   }
 }
 
 const VALIDATORS = {
   silent: validateBooleanOpt,
   exitCode: validateExitCode,
   timeout: validateTimeout,
-  classes: validateClasses,
 }
-
-const BEAUTIFUL_ERROR_OPTS = new Set([
-  'stack',
-  'props',
-  'colors',
-  'icon',
-  'header',
-])