Memory-safe Polyfill Implementation for `AbortSignal.any`

polyfill.js

const registry = new FinalizationRegistry((callback) => void callback());

export function polyfillAbortSignalAny() {
  /** @param {AbortSignal[]} signals */
  return (signals) => {
    // if (AbortSignal.any) {
    //   return AbortSignal.any(signals);
    // }
    const controller = new AbortController();
    for (const signal of signals) {
      if (signal.aborted) {
        controller.abort(signal.reason);
        return controller.signal;
      }
    }
    const controllerRef = new WeakRef(controller);
    /** @type {[WeakRef<AbortSignal>, (() => void)][]} */
    const eventListenerPairs = [];
    let followingCount = signals.length;

    signals.forEach((signal) => {
      const signalRef = new WeakRef(signal);
      function abort() {
        controllerRef.deref()?.abort(signalRef.deref()?.reason);
      }
      signal.addEventListener("abort", abort);
      eventListenerPairs.push([signalRef, abort]);
      registry.register(signal, () => !--followingCount && clear(), signal);
    });
    function clear() {
      eventListenerPairs.forEach(([signalRef, abort]) => {
        const signal = signalRef.deref();
        if (signal) {
          signal.removeEventListener("abort", abort);
          registry.unregister(signal);
        }
        const controller = controllerRef.deref();
        if (controller) {
          registry.unregister(controller.signal);
          delete controller.signal.__controller;
        }
        console.log("clear", ++count);
      });
    }

    const { signal } = controller;

    registry.register(signal, clear, signal);
    signal.addEventListener("abort", clear);

    registry.register(controller, () => console.log("controller", count));

    signal.__controller = controller;

    return signal;
  };
}

export let count = 0; // for test only

test.js

// node --expose-gc

({ polyfillAbortSignalAny } = await import("./polyfill.js"));

any = polyfillAbortSignalAny();

a = Array.from({ length: 2 }).map(() => { const c = new AbortController(); return [c, any([c.signal])]; })

[x, y] = a[0]

x.abort()

// a = a.map(([x, y]) => x) // to remove the references for followers
// a = a.map(([x, y]) => y) // to remove the references for origins

gc()


// look at the output

Thank you for sharing this polyfill!
I noticed that the check for signal.aborted is missing in the implementation. Including this check would ensure that already aborted signals are handled correctly.
Thanks again!

Thank you for your advice! I added a check for each signal and early return if any of them is aborted. I think this would solve this case.