Rename info.error to info.value

Author: ehmicky

src/events.js

@@ -3,14 +3,13 @@
 const { handleEvent } = require('./handle')
 
 // List of all handled events
-// Each event must pass its related `error` or `promise` to the generic
-// `handleEvent()`
-const uncaughtException = function(context, error) {
-  handleEvent({ ...context, error })
+// Each event must pass its related `value` to the generic `handleEvent()`
+const uncaughtException = function(context, value) {
+  handleEvent({ ...context, value })
 }
 
-const warning = function(context, error) {
-  handleEvent({ ...context, error })
+const warning = function(context, value) {
+  handleEvent({ ...context, value })
 }
 
 const unhandledRejection = function(context, value, promise) {

src/handle.js

@@ -14,19 +14,17 @@ const handleEvent = async function({
   eventName,
   previousEvents,
   mEmitLimitedWarning,
-  error,
   promise,
   value,
   nextRejected,
   nextValue,
 }) {
-  if (isLimited({ previousEvents, mEmitLimitedWarning, eventName, error })) {
+  if (isLimited({ previousEvents, mEmitLimitedWarning, eventName, value })) {
     return
   }
 
   const info = await getInfo({
     eventName,
-    error,
     promise,
     value,
     nextRejected,

src/info.js

@@ -2,10 +2,9 @@
 
 const { pickBy } = require('./utils')
 
-// Retrieve `info` object representing the current error information
+// Retrieve `info` object representing the current event information
 const getInfo = async function({
   eventName,
-  error,
   promise,
   value,
   nextRejected,
@@ -17,24 +16,17 @@ const getInfo = async function({
     value,
   })
 
-  const info = {
-    eventName,
-    error,
-    rejected,
-    value: valueA,
-    nextRejected,
-    nextValue,
-  }
+  const info = { eventName, rejected, value: valueA, nextRejected, nextValue }
 
-  const infoA = pickBy(info, value => value !== undefined)
+  const infoA = pickBy(info, infoVal => infoVal !== undefined)
   return infoA
 }
 
 // Retrieve promise's resolved/rejected state and value.
 const parsePromise = async function({ eventName, promise, value }) {
-  // `uncaughtException` and `warning` events do not have `promise`.
+  // `uncaughtException` and `warning` events do not have `rejected`.
   if (promise === undefined) {
-    return {}
+    return { value }
   }
 
   // `unhandledRejection` should not use the following code because:

src/limit.js

@@ -19,9 +19,9 @@ const isLimited = function({
   previousEvents,
   mEmitLimitedWarning,
   eventName,
-  error,
+  value,
 }) {
-  if (isLimitedWarning({ eventName, error })) {
+  if (isLimitedWarning({ eventName, value })) {
     return false
   }
 
@@ -46,7 +46,7 @@ const emitLimitedWarning = function(eventName) {
 }
 
 // The `warning` itself should not be skipped
-const isLimitedWarning = function({ eventName, error: { name, code } = {} }) {
+const isLimitedWarning = function({ eventName, value: { name, code } = {} }) {
   return eventName === 'warning' && name === ERROR_NAME && code === ERROR_CODE
 }
 

src/message.js

@@ -19,7 +19,6 @@ const defaultMessage = function({
   value,
   nextRejected,
   nextValue,
-  error,
   level,
   colors,
 }) {
@@ -28,23 +27,22 @@ const defaultMessage = function({
     value,
     nextRejected,
     nextValue,
-    error,
   })
 
   const messageA = prettify({ message, eventName, level, colors })
   return messageA
 }
 
-const uncaughtException = function({ error }) {
+const uncaughtException = function({ value }) {
   return ` (an exception was thrown but not caught)
-${serialize(error)}`
+${serialize(value)}`
 }
 
-const warning = function({ error, error: { code, detail } }) {
+const warning = function({ value, value: { code, detail } }) {
   const codeMessage = code === undefined ? '' : `(${code}) `
   const detailMessage = detail === undefined ? '' : `${detail}\n`
   return `
-${codeMessage}${detailMessage}${serialize(error)}`
+${codeMessage}${detailMessage}${serialize(value)}`
 }
 
 const unhandledRejection = function({ value }) {
@@ -57,8 +55,8 @@ const rejectionHandled = function({ value }) {
 ${serialize(value)}`
 }
 
-// The default level is `info` because it does not always indicate an
-// error: https://github.com/nodejs/node/issues/24321
+// The default level is `info` because it does not always indicate an error:
+// https://github.com/nodejs/node/issues/24321
 const multipleResolves = function({
   rejected,
   value,

src/repeat.js

@@ -39,7 +39,7 @@ const getFingerprint = function({ info }) {
 // We do not serialize `info.eventName` since this is already `eventName-wise`
 // Key order matters since fingerprint might be truncated: we serialize short
 // and non-dynamic values first.
-const INFO_PROPS = ['nextRejected', 'rejected', 'error', 'nextValue', 'value']
+const INFO_PROPS = ['nextRejected', 'rejected', 'nextValue', 'value']
 
 const FINGERPRINT_MAX_LENGTH = 1e4
 
@@ -56,7 +56,7 @@ const serializeEntry = function({ info, propName }) {
 
 const serializeValue = function({ value }) {
   if (value instanceof Error) {
-    return serializeError({ error: value })
+    return serializeError(value)
   }
 
   return stableSerialize(value)
@@ -66,7 +66,7 @@ const serializeValue = function({ value }) {
 // timestamps. This means errors are only `error.name` + `error.stack`, which
 // should be a good fingerprint.
 // Also we only keep first 10 callsites in case of infinitely recursive stack.
-const serializeError = function({ error: { name, stack } }) {
+const serializeError = function({ name, stack }) {
   const stackA = filterErrorStack({ stack })
   return `${name}\n${stackA}`
 }

test/info.js

@@ -8,7 +8,7 @@ const INFOS = [
   {
     name: 'uncaughtException',
     arg: () => true,
-    expected: { error: true },
+    expected: { value: true },
   },
   {
     name: 'warning',
@@ -18,12 +18,12 @@ const INFOS = [
       code: '500',
       detail: 'Detail',
     },
-    getInfo: ({ error, error: { message } = {}, ...info }) => ({
+    getInfo: ({ value, value: { message } = {}, ...info }) => ({
       ...info,
-      error: { ...error, message },
+      value: { ...value, message },
     }),
     expected: {
-      error: {
+      value: {
         message: 'message',
         name: 'WarningType',
         code: '500',

test/limit.js

@@ -96,6 +96,6 @@ const onlyNotLimitedWarning = function(eventName, info) {
   }
 }
 
-const isLimitedWarning = function({ eventName, error: { name } = {} }) {
+const isLimitedWarning = function({ eventName, value: { name } = {} }) {
   return eventName === 'warning' && name === 'LogProcessErrors'
 }