abort

js/globals/abort.ts

AbortController and AbortSignal globals.

AbortController / AbortSignal is the cancellation primitive used across the web platform: fetch(), stream readers, and any API that accepts a signal option. This module implements the WHATWG DOM spec surface (https://dom.spec.whatwg.org/#aborting-ongoing-activities) in pure JS.

AbortSignal extends EventTarget

AbortSignal inherits addEventListener / removeEventListener / dispatchEvent from the EventTarget global implementation. The abort event is dispatched as a proper Event instance. The onabort IDL attribute is backed by a listener registered via addEventListener, so it fires in insertion order relative to other abort listeners.

The _signalAbort WeakMap pattern

The WHATWG spec has a conceptual "abort steps" algorithm that is triggered by the controller but runs inside the signal. In a full DOM implementation this is a C++ internal link. Here we approximate it with WeakMaps.

In AbortSignal's constructor, closures are created that have direct access to this.#aborted and this.#reason. They are stored in the module-level _signalAbort and _signalMarkAbort WeakMaps, keyed on the signal instance. AbortController.abort() calls _signalAbort.get(this.#signal) to retrieve and invoke the trigger. Aborting is two-phase, matching the spec: first every affected signal (the source plus its transitive dependents) is marked aborted and its reason recorded, then abort events are dispatched in that same order. An abort listener therefore always observes aborted === true on every related signal, and sources fire before their dependents.

AbortSignal.timeout(ms)

Coerces ms with Number() and accepts only finite, non-negative delays. Invalid values throw RangeError before a signal is created. Uses internal:runtime/loop to set a timer. The import is done lazily to avoid a circular dependency at module load time. The timer is not externally cancelable; it either fires and aborts the signal or is ignored if the realm exits first.

AbortSignal.any(signals)

Validates that the input is iterable and every element is an AbortSignal. If any input is already aborted, the output signal is created pre-aborted with that input's reason. Otherwise the output is registered as a dependent of each input's source signals (composite signals from a previous any() call are flattened to their original sources), so a single controller abort marks the whole dependency graph before any abort event fires. The first source to abort wins; later aborts are ignored because signal state is immutable once settled.

// AbortController and AbortSignal are available via globalThis

const controller = new AbortController();
const { signal } = controller;

signal.addEventListener('abort', () => console.log('aborted:', signal.reason));
controller.abort();
// → signal.aborted === true

// Static factories:
const done = AbortSignal.abort(new Error('done'));  // pre-aborted signal
const timed = AbortSignal.timeout(5000);            // aborts after 5s with a TimeoutError
const merged = AbortSignal.any([signal, timed]);    // aborts when any input aborts

Classes

const controller = new AbortController();
const { signal } = controller;

async function poll(signal: AbortSignal) {
  while (true) {
    signal.throwIfAborted();
    await fetch('https://example.com/status', { signal });
  }
}

const work = poll(signal).catch((err) => console.log('stopped:', err));
controller.abort(new Error('shutting down'));

const signal = AbortSignal.abort('done');
signal.aborted; // true

const controller = new AbortController();
controller.signal.aborted; // false
controller.abort();
controller.signal.aborted; // true

const signal = AbortSignal.abort(new Error('stop'));
signal.reason.message; // "stop"

const controller = new AbortController();
controller.signal.onabort = (event) => console.log(event.type);
controller.abort();

const controller = new AbortController();
controller.signal.onabort = null;

const signal = AbortSignal.abort('cancelled');
signal.throwIfAborted(); // throws "cancelled"

const signal = AbortSignal.abort();
signal.dispatchEvent(new Event('custom'));

const signal = AbortSignal.abort('done');
signal.aborted; // true
signal.reason; // "done"

const signal = AbortSignal.timeout(1000);
signal.addEventListener('abort', () => console.log(signal.reason.name));

const a = new AbortController();
const b = new AbortController();
const signal = AbortSignal.any([a.signal, b.signal]);
b.abort('winner');
signal.reason; // "winner"

const controller = new AbortController();

const response = fetch('https://example.com/large-file', {
  signal: controller.signal,
});

// Give up if the download has not finished in five seconds.
setTimeout(() => controller.abort(new Error('took too long')), 5000);

try {
  await response;
} catch (err) {
  if (controller.signal.aborted) console.log('cancelled:', controller.signal.reason);
}

const controller = new AbortController();
const signal = controller.signal;
controller.abort();
signal.aborted; // true

const controller = new AbortController();
controller.abort(new Error('cancelled'));
controller.signal.throwIfAborted();