Quick start

1. A request with a deadline

import { 
class EnhancedAbortController
An AbortController with .NET CancellationTokenSource features. It is an AbortController,
and controller.signal is a real AbortSignal: pass it to fetch, AbortSignal.any, streams,
timers and any other API that takes a signal.
@example 
const controller = new EnhancedAbortController().abortAfter(TimeSpan.fromSeconds(5));
const response = await fetch(url, { signal: controller.signal });
EnhancedAbortController, 
class TimeSpan
An immutable time interval, stored in milliseconds. Modeled on .NET's TimeSpan.
@example 
controller.abortAfter(TimeSpan.fromSeconds(30));
TimeSpan.fromMinutes(1).add(TimeSpan.fromSeconds(30)).totalSeconds; // 90
TimeSpan, 
function isAbortError(error: unknown): boolean
True for every way an aborted operation fails: this library's
AbortError
, and any error
named AbortError or TimeoutError (the DOMExceptions that fetch, AbortSignal.timeout,
abortAfter and throwIfAborted produce).
@example 
try {
  await fetch(url, { signal: controller.signal });
} catch (error) {
  if (isAbortError(error)) return; // cancelled or timed out
  throw error;
}
isAbortError, 
function isTimeoutError(error: unknown): boolean
True if error is a timeout: a TimeoutError from abortAfter, timeout() or AbortSignal.timeout,
also when wrapped: Node core APIs (fs/promises, timers/promises, streams, events.once) reject with an
AbortError whose cause is the signal's reason.
isTimeoutError } from '@ylcnfrht/enhanced-abort-controller';

using 
using controller: EnhancedAbortController
controller = new 
new EnhancedAbortController(): EnhancedAbortController
An AbortController with .NET CancellationTokenSource features. It is an AbortController,
and controller.signal is a real AbortSignal: pass it to fetch, AbortSignal.any, streams,
timers and any other API that takes a signal.
@example 
const controller = new EnhancedAbortController().abortAfter(TimeSpan.fromSeconds(5));
const response = await fetch(url, { signal: controller.signal });
EnhancedAbortController().
EnhancedAbortController.abortAfter(delay: Delay): EnhancedAbortController
Aborts after delay, like .NET's CancelAfter: calling it again replaces the previous schedule,
and Infinity / -1 / TimeSpan.infinite cancel it. The reason is a DOMException named
TimeoutError, as with AbortSignal.timeout. The timer never keeps the process alive, and delays
longer than 24.8 days work. Does nothing once aborted. Returns the controller, for chaining.
@throws ― RangeError for NaN, negative (other than -1) or non-numeric delays.
@throws ― Error if the controller was disposed.
abortAfter(
class TimeSpan
An immutable time interval, stored in milliseconds. Modeled on .NET's TimeSpan.
@example 
controller.abortAfter(TimeSpan.fromSeconds(30));
TimeSpan.fromMinutes(1).add(TimeSpan.fromSeconds(30)).totalSeconds; // 90
TimeSpan.
TimeSpan.fromSeconds(seconds: number): TimeSpan
fromSeconds(5));

try {
  const 
const response: Response
response = await 
function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
fetch(
const url: string
url, { 
RequestInit.signal?: AbortSignal | null | undefined
An AbortSignal to set request's signal.
signal: 
using controller: EnhancedAbortController
controller.
EnhancedAbortController.signal: EnhancedSignal
The controller's signal: a real AbortSignal, always the same object.
signal });
  
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(
const response: Response
response.
Response.status: number
The status read-only property of the Response interface contains the HTTP status codes of the response.
MDN Reference
status);
} catch (
var error: unknown
error) {
  if (!
function isAbortError(error: unknown): boolean
True for every way an aborted operation fails: this library's
AbortError
, and any error
named AbortError or TimeoutError (the DOMExceptions that fetch, AbortSignal.timeout,
abortAfter and throwIfAborted produce).
@example 
try {
  await fetch(url, { signal: controller.signal });
} catch (error) {
  if (isAbortError(error)) return; // cancelled or timed out
  throw error;
}
isAbortError(
var error: unknown
error)) throw 
var error: unknown
error;
  
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(
function isTimeoutError(error: unknown): boolean
True if error is a timeout: a TimeoutError from abortAfter, timeout() or AbortSignal.timeout,
also when wrapped: Node core APIs (fs/promises, timers/promises, streams, events.once) reject with an
AbortError whose cause is the signal's reason.
isTimeoutError(
var error: unknown
error) ? 'timed out' : 'cancelled');
}

controller.signal is a real AbortSignal, so fetch takes it directly. abortAfter returns the controller, so you can chain it. using disposes the controller at the end of the block, which clears the timer if the request finished first.

2. Move the deadline

abortAfter works like .NET’s CancelAfter: each call replaces the previous schedule.

const 
const idle: EnhancedAbortController
idle = new 
new EnhancedAbortController(): EnhancedAbortController
An AbortController with .NET CancellationTokenSource features. It is an AbortController,
and controller.signal is a real AbortSignal: pass it to fetch, AbortSignal.any, streams,
timers and any other API that takes a signal.
@example 
const controller = new EnhancedAbortController().abortAfter(TimeSpan.fromSeconds(5));
const response = await fetch(url, { signal: controller.signal });
EnhancedAbortController().
EnhancedAbortController.abortAfter(delay: Delay): EnhancedAbortController
Aborts after delay, like .NET's CancelAfter: calling it again replaces the previous schedule,
and Infinity / -1 / TimeSpan.infinite cancel it. The reason is a DOMException named
TimeoutError, as with AbortSignal.timeout. The timer never keeps the process alive, and delays
longer than 24.8 days work. Does nothing once aborted. Returns the controller, for chaining.
@throws ― RangeError for NaN, negative (other than -1) or non-numeric delays.
@throws ― Error if the controller was disposed.
abortAfter(30_000);

// An idle timeout: every chunk pushes the deadline back.
function onChunk(cb: () => void): void
onChunk(() => 
const idle: EnhancedAbortController
idle.
EnhancedAbortController.abortAfter(delay: Delay): EnhancedAbortController
Aborts after delay, like .NET's CancelAfter: calling it again replaces the previous schedule,
and Infinity / -1 / TimeSpan.infinite cancel it. The reason is a DOMException named
TimeoutError, as with AbortSignal.timeout. The timer never keeps the process alive, and delays
longer than 24.8 days work. Does nothing once aborted. Returns the controller, for chaining.
@throws ― RangeError for NaN, negative (other than -1) or non-numeric delays.
@throws ― Error if the controller was disposed.
abortAfter(30_000));

// Infinity (or -1, or TimeSpan.infinite) cancels the schedule.
const idle: EnhancedAbortController
idle.
EnhancedAbortController.abortAfter(delay: Delay): EnhancedAbortController
Aborts after delay, like .NET's CancelAfter: calling it again replaces the previous schedule,
and Infinity / -1 / TimeSpan.infinite cancel it. The reason is a DOMException named
TimeoutError, as with AbortSignal.timeout. The timer never keeps the process alive, and delays
longer than 24.8 days work. Does nothing once aborted. Returns the controller, for chaining.
@throws ― RangeError for NaN, negative (other than -1) or non-numeric delays.
@throws ― Error if the controller was disposed.
abortAfter(
var Infinity: number
Infinity);

3. A step inside a request

A linked controller aborts when its parent does, with the parent’s reason. Give it its own deadline too:

{
  using 
using step: EnhancedAbortController
step = 
class EnhancedAbortController
An AbortController with .NET CancellationTokenSource features. It is an AbortController,
and controller.signal is a real AbortSignal: pass it to fetch, AbortSignal.any, streams,
timers and any other API that takes a signal.
@example 
const controller = new EnhancedAbortController().abortAfter(TimeSpan.fromSeconds(5));
const response = await fetch(url, { signal: controller.signal });
EnhancedAbortController.
EnhancedAbortController.createLinkedController<EnhancedAbortController>(this: new () => EnhancedAbortController, ...signals: Array<AbortSignal | null | undefined>): EnhancedAbortController
A controller that aborts as soon as any of signals aborts, with that signal's reason, like .NET's
CreateLinkedTokenSource. Aborting the linked controller does not affect the parents. Its listeners
on the parents are removed when it aborts or is disposed, so short-lived links on a long-lived parent
don't leak. undefined/null entries (optional signals) and EnhancedAbortSignal.none are skipped.
createLinkedController(
const request: {
    signal: AbortSignal;
}
request.
signal: AbortSignal
signal).
EnhancedAbortController.abortAfter(delay: Delay): EnhancedAbortController
Aborts after delay, like .NET's CancelAfter: calling it again replaces the previous schedule,
and Infinity / -1 / TimeSpan.infinite cancel it. The reason is a DOMException named
TimeoutError, as with AbortSignal.timeout. The timer never keeps the process alive, and delays
longer than 24.8 days work. Does nothing once aborted. Returns the controller, for chaining.
@throws ― RangeError for NaN, negative (other than -1) or non-numeric delays.
@throws ― Error if the controller was disposed.
abortAfter(2000);
  await 
function loadUser(signal: AbortSignal): Promise<void>
loadUser(
using step: EnhancedAbortController
step.
EnhancedAbortController.signal: EnhancedSignal
The controller's signal: a real AbortSignal, always the same object.
signal); // stops when the request aborts or after 2 s
} // disposed: its listener on request.signal is gone

4. Cleanup when a signal aborts

const 
const controller: EnhancedAbortController
controller = new 
new EnhancedAbortController(): EnhancedAbortController
An AbortController with .NET CancellationTokenSource features. It is an AbortController,
and controller.signal is a real AbortSignal: pass it to fetch, AbortSignal.any, streams,
timers and any other API that takes a signal.
@example 
const controller = new EnhancedAbortController().abortAfter(TimeSpan.fromSeconds(5));
const response = await fetch(url, { signal: controller.signal });
EnhancedAbortController();

// Built into the controller's signal:
const controller: EnhancedAbortController
controller.
EnhancedAbortController.signal: EnhancedSignal
The controller's signal: a real AbortSignal, always the same object.
signal.
EnhancedSignal.register(callback: (reason: unknown) => void): AbortRegistration
Same as register(signal, callback).
register((
reason: unknown
reason) => 
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log('aborted because', 
reason: unknown
reason));

// For any AbortSignal, with a handle:
using 
using closeOnAbort: AbortRegistration
closeOnAbort = 
function register(signal: AbortSignal, callback: (reason: unknown) => void): AbortRegistration
Runs callback with the signal's reason when signal aborts, like .NET's CancellationToken.Register.
Works with any AbortSignal (from fetch, a framework, AbortSignal.timeout, ...).

If the signal has already aborted, the callback runs synchronously, now, and its exceptions
propagate to the caller of register().
Otherwise it runs once, as an abort event listener: an exception it throws is reported like any
event-listener exception (in Node, an uncaught exception), so handle errors inside the callback.
Call unregister() (or using) on the result when the guarded work finishes.
register(
const someSignal: AbortSignal
someSignal, () => 
const socket: {
    destroy(error?: Error): void;
}
socket.
function destroy(error?: Error): void
destroy());

const controller: EnhancedAbortController
controller.
AbortController.abort(reason?: any): void
The abort() method of the AbortController interface aborts an asynchronous operation before it has completed.
MDN Reference
abort('done');
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(await 
const controller: EnhancedAbortController
controller.
EnhancedAbortController.signal: EnhancedSignal
The controller's signal: a real AbortSignal, always the same object.
signal.
EnhancedSignal.whenAborted: Promise<unknown>
Same as whenAborted(signal): resolves with the reason once the signal aborts.
whenAborted); // 'done'

Next

Signals are real AbortSignals
abortAfter & timeouts, with a live timeline
Linked controllers, with a live playground
Guides: fetch, Node APIs, Express and Fastify, testing, .NET mapping