promiseA | A simple Promises/A implementation | Reactive Programming library

You should not need to create a new promise with new Promise when you already have a promise to work with -- in your case: pSqlLines. Wrapping pSqlLines inside a new Promise wrapper is an example of the promise constructor antipattern.

Secondly, this code:

index.js

Option #1:

I think I'd tag each result in an object and then when you iterate through the results, you can know which are there and which are not. You can't really use named destructuring directly from the Promise.all() results because you don't know which results are in the Promise.all() array and which are not. So, it seems you need to iterate the results and dynamically adapt to which results are there. My guess is that there's a better overall way to code this particular case, but you'd have to show us your real code for us to offer a better approach based on that. Anyway, here's a generic iteration solution:

If I'm not wrong, HostPromiseRejectionTracker is an abstract operation ( Abstract operation in JavaScript are those which are used to aid the specification of the semantics of JavaScript language).

For Eg. When JavaScript does Coercion, converting one value type to another; it happens at compile time for JavaScript. It aids the dynamic nature of JavaScript.

In the same way HostPromiseRejectionTracker works, It checks whether there is a handle operation for Promise rejection or in simple way, are we handling rejection by using reject operation or not.

If we are not defining reject operation then it will look for the next handler, whether it is invalidating the previous error notification (In our case, this will be then handler). If the notification is not invalidated, it will notify the developer about the error.

It's the part

using NormalCompletion(value) as the result of the operation that suspended it.

from the text you quoted. It will resume the execution of the async function, and make the await expression have the value as the result. Compare the yield operation and the generator next() method for reference.

Use return Promise.all on the array of Promises and non-Promises at the end of a .then, and then you can destructure the results immediately in the next .then, no await nor async needed.

The Promise.all will resolve once all Promises in the array have resolved. The non-Promises passed to it will just be passed to the next .then.

Yes, you can use it with promises that return different types. Promise.all(iterable) as the MDN documentation states:

returns a single Promise that resolves when all of the promises passed as an iterable have resolved or when the iterable contains no promises. It rejects with the reason of the first promise that rejects.

The resolved promise will be:

... fulfilled with an array containing all the values of the iterable passed as argument (also non-promise values).

Its return type is an Array, but because each element in a javascript array can contain any type, you can do exactly what you described. Below is an example, and from the console output you can see undefined is returned for two of the elements, as well as a Number and a String type.

The then() method returns a Promise. See docs.

A promise has a handler method. Once a Promise is fulfilled or rejected, the respective handler function will be called asynchronously. The behavior of the handler function follows a specific set of rules as stated here.

Let's go over them one by one. Here is the code we will inspect side by side. Its nothing special, just a chain of promises returning values.

Please try: