Prevent Bluebird warning about a promise not being returned from a handler

CHANGELOG.md

@@ -9,6 +9,10 @@
 > - 🏠 Internal
 > - 💅 Polish
 
+## Unreleased
+
+* 🐛 Prevent [warnings from Bluebird](http://bluebirdjs.com/docs/warning-explanations.html#warning-a-promise-was-created-in-a-handler-but-was-not-returned-from-it) about a promise being created within a handler but not being returned from a handler. ([#91](https://github.com/MattiasBuelens/web-streams-polyfill/pull/91))
+
 ## v4.0.0-beta.1 (2021-09-06)
 
 * 💥 Rework the list of variants to have more modern defaults.

src/lib/helpers/webidl.ts

@@ -30,22 +30,25 @@ export function PerformPromiseThen<T, TResult1 = T, TResult2 = never>(
   return originalPromiseThen.call(promise, onFulfilled, onRejected) as Promise<TResult1 | TResult2>;
 }
 
+// Bluebird logs a warning when a promise is created within a fulfillment handler, but then isn't returned
+// from that handler. To prevent this, return null instead of void from all handlers.
+// http://bluebirdjs.com/docs/warning-explanations.html#warning-a-promise-was-created-in-a-handler-but-was-not-returned-from-it
 export function uponPromise<T>(
   promise: Promise<T>,
-  onFulfilled?: (value: T) => void | PromiseLike<void>,
-  onRejected?: (reason: any) => void | PromiseLike<void>): void {
+  onFulfilled?: (value: T) => null | PromiseLike<null>,
+  onRejected?: (reason: any) => null | PromiseLike<null>): void {
   PerformPromiseThen(
     PerformPromiseThen(promise, onFulfilled, onRejected),
     undefined,
     rethrowAssertionErrorRejection
   );
 }
 
-export function uponFulfillment<T>(promise: Promise<T>, onFulfilled: (value: T) => void | PromiseLike<void>): void {
+export function uponFulfillment<T>(promise: Promise<T>, onFulfilled: (value: T) => null | PromiseLike<null>): void {
   uponPromise(promise, onFulfilled);
 }
 
-export function uponRejection(promise: Promise<unknown>, onRejected: (reason: any) => void | PromiseLike<void>): void {
+export function uponRejection(promise: Promise<unknown>, onRejected: (reason: any) => null | PromiseLike<null>): void {
   uponPromise(promise, undefined, onRejected);
 }
 

src/lib/readable-stream/byte-stream-controller.ts

@@ -421,9 +421,12 @@ function ReadableByteStreamControllerCallPullIfNeeded(controller: ReadableByteSt
         controller._pullAgain = false;
         ReadableByteStreamControllerCallPullIfNeeded(controller);
       }
+
+      return null;
     },
     e => {
       ReadableByteStreamControllerError(controller, e);
+      return null;
     }
   );
 }
@@ -981,9 +984,11 @@ export function SetUpReadableByteStreamController(stream: ReadableByteStream,
       assert(!controller._pullAgain);
 
       ReadableByteStreamControllerCallPullIfNeeded(controller);
+      return null;
     },
     r => {
       ReadableByteStreamControllerError(controller, r);
+      return null;
     }
   );
 }
@@ -995,18 +1000,24 @@ export function SetUpReadableByteStreamControllerFromUnderlyingSource(
 ) {
   const controller: ReadableByteStreamController = Object.create(ReadableByteStreamController.prototype);
 
-  let startAlgorithm: () => void | PromiseLike<void> = () => undefined;
-  let pullAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);
-  let cancelAlgorithm: (reason: any) => Promise<void> = () => promiseResolvedWith(undefined);
+  let startAlgorithm: () => void | PromiseLike<void>;
+  let pullAlgorithm: () => Promise<void>;
+  let cancelAlgorithm: (reason: any) => Promise<void>;
 
   if (underlyingByteSource.start !== undefined) {
     startAlgorithm = () => underlyingByteSource.start!(controller);
+  } else {
+    startAlgorithm = () => undefined;
   }
   if (underlyingByteSource.pull !== undefined) {
     pullAlgorithm = () => underlyingByteSource.pull!(controller);
+  } else {
+    pullAlgorithm = () => promiseResolvedWith(undefined);
   }
   if (underlyingByteSource.cancel !== undefined) {
     cancelAlgorithm = reason => underlyingByteSource.cancel!(reason);
+  } else {
+    cancelAlgorithm = () => promiseResolvedWith(undefined);
   }
 
   const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;

src/lib/readable-stream/default-controller.ts

@@ -184,9 +184,12 @@ function ReadableStreamDefaultControllerCallPullIfNeeded(controller: ReadableStr
         controller._pullAgain = false;
         ReadableStreamDefaultControllerCallPullIfNeeded(controller);
       }
+
+      return null;
     },
     e => {
       ReadableStreamDefaultControllerError(controller, e);
+      return null;
     }
   );
 }
@@ -359,9 +362,11 @@ export function SetUpReadableStreamDefaultController<R>(stream: ReadableStream<R
       assert(!controller._pullAgain);
 
       ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+      return null;
     },
     r => {
       ReadableStreamDefaultControllerError(controller, r);
+      return null;
     }
   );
 }
@@ -374,18 +379,24 @@ export function SetUpReadableStreamDefaultControllerFromUnderlyingSource<R>(
 ) {
   const controller: ReadableStreamDefaultController<R> = Object.create(ReadableStreamDefaultController.prototype);
 
-  let startAlgorithm: () => void | PromiseLike<void> = () => undefined;
-  let pullAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);
-  let cancelAlgorithm: (reason: any) => Promise<void> = () => promiseResolvedWith(undefined);
+  let startAlgorithm: () => void | PromiseLike<void>;
+  let pullAlgorithm: () => Promise<void>;
+  let cancelAlgorithm: (reason: any) => Promise<void>;
 
   if (underlyingSource.start !== undefined) {
     startAlgorithm = () => underlyingSource.start!(controller);
+  } else {
+    startAlgorithm = () => undefined;
   }
   if (underlyingSource.pull !== undefined) {
     pullAlgorithm = () => underlyingSource.pull!(controller);
+  } else {
+    pullAlgorithm = () => promiseResolvedWith(undefined);
   }
   if (underlyingSource.cancel !== undefined) {
     cancelAlgorithm = reason => underlyingSource.cancel!(reason);
+  } else {
+    cancelAlgorithm = () => promiseResolvedWith(undefined);
   }
 
   SetUpReadableStreamDefaultController(

src/lib/readable-stream/pipe.ts

@@ -132,6 +132,7 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
       } else {
         shutdown(true, storedError);
       }
+      return null;
     });
 
     // Errors must be propagated backward
@@ -141,6 +142,7 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
       } else {
         shutdown(true, storedError);
       }
+      return null;
     });
 
     // Closing must be propagated forward
@@ -150,6 +152,7 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
       } else {
         shutdown();
       }
+      return null;
     });
 
     // Closing must be propagated backward
@@ -177,15 +180,15 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
 
     function isOrBecomesErrored(stream: ReadableStream | WritableStream,
                                 promise: Promise<void>,
-                                action: (reason: any) => void) {
+                                action: (reason: any) => null) {
       if (stream._state === 'errored') {
         action(stream._storedError);
       } else {
         uponRejection(promise, action);
       }
     }
 
-    function isOrBecomesClosed(stream: ReadableStream | WritableStream, promise: Promise<void>, action: () => void) {
+    function isOrBecomesClosed(stream: ReadableStream | WritableStream, promise: Promise<void>, action: () => null) {
       if (stream._state === 'closed') {
         action();
       } else {
@@ -205,12 +208,13 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
         doTheRest();
       }
 
-      function doTheRest() {
+      function doTheRest(): null {
         uponPromise(
           action(),
           () => finalize(originalIsError, originalError),
           newError => finalize(true, newError)
         );
+        return null;
       }
     }
 
@@ -227,7 +231,7 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
       }
     }
 
-    function finalize(isError?: boolean, error?: any) {
+    function finalize(isError?: boolean, error?: any): null {
       WritableStreamDefaultWriterRelease(writer);
       ReadableStreamReaderGenericRelease(reader);
 
@@ -239,6 +243,8 @@ export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,
       } else {
         resolve(undefined);
       }
+
+      return null;
     }
   });
 }

src/lib/readable-stream/tee.ts

@@ -166,6 +166,7 @@ export function ReadableStreamDefaultTee<R>(stream: ReadableStream<R>,
     if (!canceled1 || !canceled2) {
       resolveCancelPromise(undefined);
     }
+    return null;
   });
 
   return [branch1, branch2];
@@ -192,13 +193,14 @@ export function ReadableByteStreamTee(stream: ReadableByteStream): [ReadableByte
   function forwardReaderError(thisReader: ReadableStreamReader<Uint8Array>) {
     uponRejection(thisReader._closedPromise, r => {
       if (thisReader !== reader) {
-        return;
+        return null;
       }
       ReadableByteStreamControllerError(branch1._readableStreamController, r);
       ReadableByteStreamControllerError(branch2._readableStreamController, r);
       if (!canceled1 || !canceled2) {
         resolveCancelPromise(undefined);
       }
+      return null;
     });
   }
 

src/lib/transform-stream.ts

@@ -371,22 +371,26 @@ function SetUpTransformStreamDefaultControllerFromTransformer<I, O>(stream: Tran
                                                                     transformer: ValidatedTransformer<I, O>) {
   const controller: TransformStreamDefaultController<O> = Object.create(TransformStreamDefaultController.prototype);
 
-  let transformAlgorithm = (chunk: I): Promise<void> => {
-    try {
-      TransformStreamDefaultControllerEnqueue(controller, chunk as unknown as O);
-      return promiseResolvedWith(undefined);
-    } catch (transformResultE) {
-      return promiseRejectedWith(transformResultE);
-    }
-  };
-
-  let flushAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);
+  let transformAlgorithm: (chunk: I) => Promise<void>;
+  let flushAlgorithm: () => Promise<void>;
 
   if (transformer.transform !== undefined) {
     transformAlgorithm = chunk => transformer.transform!(chunk, controller);
+  } else {
+    transformAlgorithm = chunk => {
+      try {
+        TransformStreamDefaultControllerEnqueue(controller, chunk as unknown as O);
+        return promiseResolvedWith(undefined);
+      } catch (transformResultE) {
+        return promiseRejectedWith(transformResultE);
+      }
+    };
   }
+
   if (transformer.flush !== undefined) {
     flushAlgorithm = () => transformer.flush!(controller);
+  } else {
+    flushAlgorithm = () => promiseResolvedWith(undefined);
   }
 
   SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);

src/lib/writable-stream.ts

@@ -447,10 +447,12 @@ function WritableStreamFinishErroring(stream: WritableStream) {
     () => {
       abortRequest._resolve();
       WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+      return null;
     },
     (reason: any) => {
       abortRequest._reject(reason);
       WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+      return null;
     });
 }
 
@@ -1081,11 +1083,13 @@ function SetUpWritableStreamDefaultController<W>(stream: WritableStream<W>,
       assert(stream._state === 'writable' || stream._state === 'erroring');
       controller._started = true;
       WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+      return null;
     },
     r => {
       assert(stream._state === 'writable' || stream._state === 'erroring');
       controller._started = true;
       WritableStreamDealWithRejection(stream, r);
+      return null;
     }
   );
 }
@@ -1096,22 +1100,30 @@ function SetUpWritableStreamDefaultControllerFromUnderlyingSink<W>(stream: Writa
                                                                    sizeAlgorithm: QueuingStrategySizeCallback<W>) {
   const controller = Object.create(WritableStreamDefaultController.prototype);
 
-  let startAlgorithm: () => void | PromiseLike<void> = () => undefined;
-  let writeAlgorithm: (chunk: W) => Promise<void> = () => promiseResolvedWith(undefined);
-  let closeAlgorithm: () => Promise<void> = () => promiseResolvedWith(undefined);
-  let abortAlgorithm: (reason: any) => Promise<void> = () => promiseResolvedWith(undefined);
+  let startAlgorithm: () => void | PromiseLike<void>;
+  let writeAlgorithm: (chunk: W) => Promise<void>;
+  let closeAlgorithm: () => Promise<void>;
+  let abortAlgorithm: (reason: any) => Promise<void>;
 
   if (underlyingSink.start !== undefined) {
     startAlgorithm = () => underlyingSink.start!(controller);
+  } else {
+    startAlgorithm = () => undefined;
   }
   if (underlyingSink.write !== undefined) {
     writeAlgorithm = chunk => underlyingSink.write!(chunk, controller);
+  } else {
+    writeAlgorithm = () => promiseResolvedWith(undefined);
   }
   if (underlyingSink.close !== undefined) {
     closeAlgorithm = () => underlyingSink.close!();
+  } else {
+    closeAlgorithm = () => promiseResolvedWith(undefined);
   }
   if (underlyingSink.abort !== undefined) {
     abortAlgorithm = reason => underlyingSink.abort!(reason);
+  } else {
+    abortAlgorithm = () => promiseResolvedWith(undefined);
   }
 
   SetUpWritableStreamDefaultController(
@@ -1217,9 +1229,11 @@ function WritableStreamDefaultControllerProcessClose(controller: WritableStreamD
     sinkClosePromise,
     () => {
       WritableStreamFinishInFlightClose(stream);
+      return null;
     },
     reason => {
       WritableStreamFinishInFlightCloseWithError(stream, reason);
+      return null;
     }
   );
 }
@@ -1246,12 +1260,14 @@ function WritableStreamDefaultControllerProcessWrite<W>(controller: WritableStre
       }
 
       WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+      return null;
     },
     reason => {
       if (stream._state === 'writable') {
         WritableStreamDefaultControllerClearAlgorithms(controller);
       }
       WritableStreamFinishInFlightWriteWithError(stream, reason);
+      return null;
     }
   );
 }