shelving 1.126.3 → 1.127.0

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.126.3",
+	"version": "1.127.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/util/async.d.ts

@@ -1,3 +1,4 @@
+import type { ImmutableArray } from "./array.js";
 import type { ValueCallback } from "./callback.js";
 import type { Report } from "./error.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
@@ -18,6 +19,20 @@ export declare function assertAsync<T>(value: PromiseLike<T> | T): asserts value
 export declare function assertPromise<T>(value: Promise<T> | T): asserts value is Promise<T>;
 /** Run any queued microtasks now. */
 export declare function runMicrotasks(): Promise<void>;
+/**
+ * Run multiple promises concurrently.
+ *
+ * DH: An issue with `Promise.all()` is: if _one_ of its promises rejects, the parent promise rejects immediately.
+ * - This leaves all of the other promises lost in unhandled purgatory.
+ * - The program may then have dangling open threads that prevent the program from exiting, even after it has returned its main result.
+ * - This function waits for the resolution of *all* promises before rejecting.
+ *
+ * @param promises Promises that we need to wait for.
+ * @throws unknown Rethrows the first error found after resolving all the promises (the first in the _list_, not the first overall).
+ */
+export declare function runConcurrent<T extends ImmutableArray<unknown>>(...promises: T): Promise<{
+    readonly [P in keyof T]: Awaited<T[P]>;
+}>;
 /** Type of `Promise` with `._resolve()` and `._reject()` methods available. */
 export declare abstract class AbstractPromise<T> extends Promise<T> {
     static get [Symbol.species](): PromiseConstructor;

package/util/async.js

@@ -37,6 +37,14 @@ export function runMicrotasks() {
     // Timeouts are part of the main event queue, and events in the main queue are run _after_ all microtasks complete.
     return new Promise(resolve => setTimeout(resolve));
 }
+export async function runConcurrent(...promises) {
+    return (await Promise.allSettled(promises)).map(_getFulfilledResult);
+}
+function _getFulfilledResult(result) {
+    if (result.status === "rejected")
+        throw result.reason;
+    return result.value;
+}
 /** Type of `Promise` with `._resolve()` and `._reject()` methods available. */
 export class AbstractPromise extends Promise {
     // Make `this.then()` create a `Promise` not a `Deferred`