Avoid unpreventable unhandledRejection events

packages/babel-core/src/gensync-utils/functional.ts

@@ -3,29 +3,48 @@ import type { Handler } from "gensync";
 import { isAsync, waitFor } from "./async.ts";
 
 export function once<R>(fn: () => Handler<R>): () => Handler<R> {
-  let result: R;
+  let result: { ok: true; value: R } | { ok: false; value: unknown };
   let resultP: Promise<R>;
+  let promiseReferenced = false;
   return function* () {
-    if (result) return result;
-    if (!(yield* isAsync())) return (result = yield* fn());
-    if (resultP) return yield* waitFor(resultP);
+    if (!result) {
+      if (resultP) {
+        promiseReferenced = true;
+        return yield* waitFor(resultP);
+      }
 
-    let resolve: (result: R) => void, reject: (error: unknown) => void;
-    resultP = new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
+      if (!(yield* isAsync())) {
+        try {
+          result = { ok: true, value: yield* fn() };
+        } catch (error) {
+          result = { ok: false, value: error };
+        }
+      } else {
+        let resolve: (result: R) => void, reject: (error: unknown) => void;
+        resultP = new Promise((res, rej) => {
+          resolve = res;
+          reject = rej;
+        });
 
-    try {
-      result = yield* fn();
-      // Avoid keeping the promise around
-      // now that we have the result.
-      resultP = null;
-      resolve(result);
-      return result;
-    } catch (error) {
-      reject(error);
-      throw error;
+        try {
+          result = { ok: true, value: yield* fn() };
+          // Avoid keeping the promise around
+          // now that we have the result.
+          resultP = null;
+          // We only resolve/reject the promise if it has been actually
+          // referenced. If there are no listeners we can forget about it.
+          // In the reject case, this avoid uncatchable unhandledRejection
+          // events.
+          if (promiseReferenced) resolve(result.value);
+        } catch (error) {
+          result = { ok: false, value: error };
+          resultP = null;
+          if (promiseReferenced) reject(error);
+        }
+      }
     }
+
+    if (result.ok) return result.value;
+    else throw result.value;
   };
 }

packages/babel-core/test/async.js

@@ -306,4 +306,24 @@ describe("asynchronicity", () => {
       });
     });
   });
+
+  describe("misc", () => {
+    it("unknown preset in config file does not trigget unhandledRejection if caught", async () => {
+      process.chdir("unknown-preset");
+      const handler = jest.fn();
+
+      process.addListener("unhandledRejection", handler);
+
+      await babel.loadPartialConfigAsync().catch(() => {});
+
+      // unhandledRejection is triggered at the end of the current microtask
+      // queue. Wait for the event loop to spin to make sure that, if it were to
+      // be triggered, it would have already happened.
+      await new Promise(r => setTimeout(r, 0));
+
+      process.removeListener("unhandledRejection", handler);
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
 });

packages/babel-core/test/fixtures/async/unknown-preset/babel.config.json

@@ -0,0 +1,3 @@
+{
+  "presets": ["unknown"]
+}