Rename promiseState to rejected

Author: ehmicky

README.md

@@ -172,10 +172,10 @@ or the error emitted by
 Not defined with other events. It is usually an `Error` instance but could be
 anything.
 
-## `info.promiseState`
+## `info.rejected`
 
-String indicating whether the promise was `"resolved"` or `"rejected"`. Only
-defined with
+Boolean indicating whether the promise was resolved or rejected. Only defined
+with
 [`unhandledRejection`](https://nodejs.org/api/process.html#process_event_unhandledrejection),
 [`rejectionHandled`](https://nodejs.org/api/process.html#process_event_rejectionhandled)
 and
@@ -189,11 +189,10 @@ Value resolved/rejected by the promise. Only defined with
 and
 [`multipleResolves`](https://nodejs.org/api/process.html#process_event_multipleresolves).
 
-## `info.secondPromiseState`, `info.secondPromiseValue`
+## `info.nextRejected`, `info.secondPromiseValue`
 
-Like [`promiseState`](#infopromisestate) and
-[`promiseValue`](#infopromisevalue) but for the second time the promise was
-resolved/rejected. Only defined with
+Like [`rejected`](#inforejected) and [`promiseValue`](#infopromisevalue) but for
+the second time the promise was resolved/rejected. Only defined with
 [`multipleResolves`](https://nodejs.org/api/process.html#process_event_multipleresolves).
 
 ## `info.level`

src/events.js

@@ -23,13 +23,13 @@ const rejectionHandled = function(context, promise) {
 
 // eslint-disable-next-line max-params
 const multipleResolves = function(context, type, promise, secondPromiseValue) {
-  const secondPromiseState = TYPE_TO_STATE[type]
-  handleEvent({ ...context, promise, secondPromiseState, secondPromiseValue })
+  const nextRejected = TYPE_TO_REJECTED[type]
+  handleEvent({ ...context, promise, nextRejected, secondPromiseValue })
 }
 
-const TYPE_TO_STATE = {
-  resolve: 'resolved',
-  reject: 'rejected',
+const TYPE_TO_REJECTED = {
+  resolve: false,
+  reject: true,
 }
 
 module.exports = {

src/handle.js

@@ -17,7 +17,7 @@ const handleEvent = async function({
   error,
   promise,
   promiseValue,
-  secondPromiseState,
+  nextRejected,
   secondPromiseValue,
 }) {
   if (isLimited({ previousEvents, mEmitLimitedWarning, eventName, error })) {
@@ -29,7 +29,7 @@ const handleEvent = async function({
     error,
     promise,
     promiseValue,
-    secondPromiseState,
+    nextRejected,
     secondPromiseValue,
   })
 

src/info.js

@@ -8,10 +8,10 @@ const getInfo = async function({
   error,
   promise,
   promiseValue,
-  secondPromiseState,
+  nextRejected,
   secondPromiseValue,
 }) {
-  const { promiseState, promiseValue: promiseValueA } = await parsePromise({
+  const { rejected, promiseValue: promiseValueA } = await parsePromise({
     eventName,
     promise,
     promiseValue,
@@ -20,9 +20,9 @@ const getInfo = async function({
   const info = {
     eventName,
     error,
-    promiseState,
+    rejected,
     promiseValue: promiseValueA,
-    secondPromiseState,
+    nextRejected,
     secondPromiseValue,
   }
 
@@ -38,17 +38,17 @@ const parsePromise = async function({ eventName, promise, promiseValue }) {
   }
 
   // `unhandledRejection` should not use the following code because:
-  //  - we already know `promiseState` and `promiseValue`
+  //  - we already know `rejected` and `promiseValue`
   //  - using `try/catch` will fire `rejectionHandled`
   if (eventName === 'unhandledRejection') {
-    return { promiseState: 'rejected', promiseValue }
+    return { rejected: true, promiseValue }
   }
 
   // `rejectionHandled` and `multipleResolves` use `await promise`
   try {
-    return { promiseState: 'resolved', promiseValue: await promise }
+    return { rejected: false, promiseValue: await promise }
   } catch (error) {
-    return { promiseState: 'rejected', promiseValue: error }
+    return { rejected: true, promiseValue: error }
   }
 }
 

src/message.js

@@ -15,18 +15,18 @@ const getMessage = function({ opts, info, level, colors }) {
 // Default `opts.message()`
 const defaultMessage = function({
   eventName,
-  promiseState,
+  rejected,
   promiseValue,
-  secondPromiseState,
+  nextRejected,
   secondPromiseValue,
   error,
   level,
   colors,
 }) {
   const message = MESSAGES[eventName]({
-    promiseState,
+    rejected,
     promiseValue,
-    secondPromiseState,
+    nextRejected,
     secondPromiseValue,
     error,
   })
@@ -60,19 +60,24 @@ ${serialize(promiseValue)}`
 // The default level is `info` because it does not always indicate an
 // error: https://github.com/nodejs/node/issues/24321
 const multipleResolves = function({
-  promiseState,
+  rejected,
   promiseValue,
-  secondPromiseState,
+  nextRejected,
   secondPromiseValue,
 }) {
-  // istanbul ignore next
-  const again = promiseState === secondPromiseState ? ' again' : ''
-  // istanbul ignore next
-  const state = again ? promiseState : 'resolved/rejected'
+  const rejectedStr = REJECTED_NAME[rejected]
+  const nextRejectedStr = REJECTED_NAME[nextRejected]
+  const again = rejected === nextRejected ? ' again' : ''
+  const state = again ? rejectedStr : 'resolved/rejected'
 
   return ` (a promise was ${state} multiple times)
-Initially ${promiseState} with: ${serialize(promiseValue)}
-Then ${secondPromiseState}${again} with: ${serialize(secondPromiseValue)}`
+Initially ${rejectedStr} with: ${serialize(promiseValue)}
+Then ${nextRejectedStr}${again} with: ${serialize(secondPromiseValue)}`
+}
+
+const REJECTED_NAME = {
+  true: 'rejected',
+  false: 'resolved',
 }
 
 const MESSAGES = {

src/repeat.js

@@ -40,8 +40,8 @@ const getFingerprint = function({ info }) {
 // Key order matters since fingerprint might be truncated: we serialize short
 // and non-dynamic values first.
 const INFO_PROPS = [
-  'secondPromiseState',
-  'promiseState',
+  'nextRejected',
+  'rejected',
   'error',
   'secondPromiseValue',
   'promiseValue',

test/info.js

@@ -34,20 +34,20 @@ const INFOS = [
   {
     name: 'unhandledRejection',
     arg: () => true,
-    expected: { promiseState: 'rejected', promiseValue: true },
+    expected: { rejected: true, promiseValue: true },
   },
   {
     name: 'rejectionHandled',
     arg: () => true,
-    expected: { promiseState: 'rejected', promiseValue: true },
+    expected: { rejected: true, promiseValue: true },
   },
   {
     name: 'multipleResolves',
     arg: [['resolve', () => true], ['reject', () => false]],
     expected: {
-      promiseState: 'resolved',
+      rejected: false,
       promiseValue: true,
-      secondPromiseState: 'rejected',
+      nextRejected: true,
       secondPromiseValue: false,
     },
   },