Rename info.promiseValue to info.value

Author: ehmicky

README.md

@@ -163,14 +163,21 @@ Can be
 or
 [`"warning"`](https://nodejs.org/api/process.html#process_event_warning).
 
-## `info.error`
+## `info.value`
 
-Either the value thrown by
-[`uncaughtException`](https://nodejs.org/api/process.html#process_event_uncaughtexception)
-or the error emitted by
-[`warning`](https://nodejs.org/api/process.html#process_event_warning).
-Not defined with other events. It is usually an `Error` instance but could be
-anything.
+Can be:
+
+- the value thrown by
+  [`uncaughtException`](https://nodejs.org/api/process.html#process_event_uncaughtexception).
+- the value resolved/rejected by the promise with
+  [`unhandledRejection`](https://nodejs.org/api/process.html#process_event_unhandledrejection),
+  [`rejectionHandled`](https://nodejs.org/api/process.html#process_event_rejectionhandled)
+  and
+  [`multipleResolves`](https://nodejs.org/api/process.html#process_event_multipleresolves).
+- the error emitted by
+  [`warning`](https://nodejs.org/api/process.html#process_event_warning).
+
+It is usually an `Error` instance but could be anything.
 
 ## `info.rejected`
 
@@ -181,14 +188,6 @@ with
 and
 [`multipleResolves`](https://nodejs.org/api/process.html#process_event_multipleresolves).
 
-## `info.promiseValue`
-
-Value resolved/rejected by the promise. Only defined with
-[`unhandledRejection`](https://nodejs.org/api/process.html#process_event_unhandledrejection),
-[`rejectionHandled`](https://nodejs.org/api/process.html#process_event_rejectionhandled)
-and
-[`multipleResolves`](https://nodejs.org/api/process.html#process_event_multipleresolves).
-
 ## `info.nextRejected`, `info.nextValue`
 
 Like [`rejected`](#inforejected) and [`value`](#infovalue) but for

src/events.js

@@ -13,8 +13,8 @@ const warning = function(context, error) {
   handleEvent({ ...context, error })
 }
 
-const unhandledRejection = function(context, promiseValue, promise) {
-  handleEvent({ ...context, promise, promiseValue })
+const unhandledRejection = function(context, value, promise) {
+  handleEvent({ ...context, promise, value })
 }
 
 const rejectionHandled = function(context, promise) {

src/handle.js

@@ -16,7 +16,7 @@ const handleEvent = async function({
   mEmitLimitedWarning,
   error,
   promise,
-  promiseValue,
+  value,
   nextRejected,
   nextValue,
 }) {
@@ -28,7 +28,7 @@ const handleEvent = async function({
     eventName,
     error,
     promise,
-    promiseValue,
+    value,
     nextRejected,
     nextValue,
   })

src/info.js

@@ -7,21 +7,21 @@ const getInfo = async function({
   eventName,
   error,
   promise,
-  promiseValue,
+  value,
   nextRejected,
   nextValue,
 }) {
-  const { rejected, promiseValue: promiseValueA } = await parsePromise({
+  const { rejected, value: valueA } = await parsePromise({
     eventName,
     promise,
-    promiseValue,
+    value,
   })
 
   const info = {
     eventName,
     error,
     rejected,
-    promiseValue: promiseValueA,
+    value: valueA,
     nextRejected,
     nextValue,
   }
@@ -31,24 +31,24 @@ const getInfo = async function({
 }
 
 // Retrieve promise's resolved/rejected state and value.
-const parsePromise = async function({ eventName, promise, promiseValue }) {
+const parsePromise = async function({ eventName, promise, value }) {
   // `uncaughtException` and `warning` events do not have `promise`.
   if (promise === undefined) {
     return {}
   }
 
   // `unhandledRejection` should not use the following code because:
-  //  - we already know `rejected` and `promiseValue`
+  //  - we already know `rejected` and `value`
   //  - using `try/catch` will fire `rejectionHandled`
   if (eventName === 'unhandledRejection') {
-    return { rejected: true, promiseValue }
+    return { rejected: true, value }
   }
 
   // `rejectionHandled` and `multipleResolves` use `await promise`
   try {
-    return { rejected: false, promiseValue: await promise }
+    return { rejected: false, value: await promise }
   } catch (error) {
-    return { rejected: true, promiseValue: error }
+    return { rejected: true, value: error }
   }
 }
 

src/limit.js

@@ -13,8 +13,8 @@ const { MAX_EVENTS } = require('./constants')
 //  - it prevents infinite recursions if `opts.log|level|message()` triggers
 //    itself an event.
 //    The `repeated` logic should prevent it most of the times, but it can still
-//    happen when `error` or `[second]promiseValue` is not an `Error` instance
-//    and contain dynamic content.
+//    happen when `[next]Value` is not an `Error` instance and contain dynamic
+//    content.
 const isLimited = function({
   previousEvents,
   mEmitLimitedWarning,

src/message.js

@@ -16,7 +16,7 @@ const getMessage = function({ opts, info, level, colors }) {
 const defaultMessage = function({
   eventName,
   rejected,
-  promiseValue,
+  value,
   nextRejected,
   nextValue,
   error,
@@ -25,7 +25,7 @@ const defaultMessage = function({
 }) {
   const message = MESSAGES[eventName]({
     rejected,
-    promiseValue,
+    value,
     nextRejected,
     nextValue,
     error,
@@ -47,21 +47,21 @@ const warning = function({ error, error: { code, detail } }) {
 ${codeMessage}${detailMessage}${serialize(error)}`
 }
 
-const unhandledRejection = function({ promiseValue }) {
+const unhandledRejection = function({ value }) {
   return ` (a promise was rejected but not handled)
-${serialize(promiseValue)}`
+${serialize(value)}`
 }
 
-const rejectionHandled = function({ promiseValue }) {
+const rejectionHandled = function({ value }) {
   return ` (a promise was rejected and handled too late)
-${serialize(promiseValue)}`
+${serialize(value)}`
 }
 
 // The default level is `info` because it does not always indicate an
 // error: https://github.com/nodejs/node/issues/24321
 const multipleResolves = function({
   rejected,
-  promiseValue,
+  value,
   nextRejected,
   nextValue,
 }) {
@@ -73,7 +73,7 @@ const multipleResolves = function({
   const state = again ? rejectedStr : 'resolved/rejected'
 
   return ` (a promise was ${state} multiple times)
-Initially ${rejectedStr} with: ${serialize(promiseValue)}
+Initially ${rejectedStr} with: ${serialize(value)}
 Then ${nextRejectedStr}${again} with: ${serialize(nextValue)}`
 }
 

src/repeat.js

@@ -39,13 +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',
-  'promiseValue',
-]
+const INFO_PROPS = ['nextRejected', 'rejected', 'error', 'nextValue', 'value']
 
 const FINGERPRINT_MAX_LENGTH = 1e4
 

test/info.js

@@ -34,19 +34,19 @@ const INFOS = [
   {
     name: 'unhandledRejection',
     arg: () => true,
-    expected: { rejected: true, promiseValue: true },
+    expected: { rejected: true, value: true },
   },
   {
     name: 'rejectionHandled',
     arg: () => true,
-    expected: { rejected: true, promiseValue: true },
+    expected: { rejected: true, value: true },
   },
   {
     name: 'multipleResolves',
     arg: [['resolve', () => true], ['reject', () => false]],
     expected: {
       rejected: false,
-      promiseValue: true,
+      value: true,
       nextRejected: true,
       nextValue: false,
     },