Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -42,6 +42,18 @@ import {AbortController} from './AbortController';
const ABORTED_KEY = Symbol('aborted');
const REASON_KEY = Symbol('reason');

type DependentSignalLinks = {
readonly signalRef: WeakRef<AbortSignal>,
readonly sourceSignalRefs: ReadonlyArray<WeakRef<AbortSignal>>,
};

const dependentSignalRefs: WeakMap<
AbortSignal,
Set<WeakRef<AbortSignal>>,
> = new WeakMap();
const dependentSignalLinks: WeakMap<AbortSignal, DependentSignalLinks> =
new WeakMap();

/**
* The signal class.
* @see https://dom.spec.whatwg.org/#abortsignal
Expand Down Expand Up @@ -111,22 +123,41 @@ export class AbortSignal extends EventTarget {
}
}

// Third pass: none of the signals is aborted, so subscribe to all of them
// and abort the resulting signal when any of them aborts.
const controller = new AbortController();
const listeners = [];
const cleanup = () => listeners.forEach(unsubscribe => unsubscribe());
const resultSignal = createAbortSignal();
const resultSources: Set<AbortSignal> = new Set();

for (let i = 0; i < signals.length; i++) {
const signal = signals[i];
const onAbort = () => {
controller.abort(signal.reason);
cleanup();
};
signal.addEventListener('abort', onAbort);
listeners.push(() => signal.removeEventListener('abort', onAbort));
const links = dependentSignalLinks.get(signal);
if (links == null) {
resultSources.add(signal);
} else {
for (const sourceRef of links.sourceSignalRefs) {
const sourceSignal = sourceRef.deref();
if (sourceSignal != null) {
resultSources.add(sourceSignal);
}
}
}
}
return controller.signal;

const resultSignalRef = new WeakRef(resultSignal);
const resultSourceRefs: Array<WeakRef<AbortSignal>> = [];
for (const sourceSignal of resultSources) {
let dependentRefs = dependentSignalRefs.get(sourceSignal);
if (dependentRefs == null) {
dependentRefs = new Set();
dependentSignalRefs.set(sourceSignal, dependentRefs);
}
dependentRefs.add(resultSignalRef);
resultSourceRefs.push(new WeakRef(sourceSignal));
}
dependentSignalLinks.set(resultSignal, {
signalRef: resultSignalRef,
sourceSignalRefs: resultSourceRefs,
});

return resultSignal;
}

[ABORTED_KEY]: boolean = false;
Expand Down Expand Up @@ -193,7 +224,44 @@ export function abortSignal(
}
signal[ABORTED_KEY] = true;
signal[REASON_KEY] = reason;

const dependentSignalsToAbort: Array<AbortSignal> = [];
const dependentRefs = dependentSignalRefs.get(signal);
if (dependentRefs != null) {
dependentSignalRefs.delete(signal);
for (const dependentRef of dependentRefs) {
const dependentSignal = dependentRef.deref();
// $FlowExpectedError[invalid-compare]
// $FlowExpectedError[prop-missing]
if (dependentSignal != null && dependentSignal[ABORTED_KEY] === false) {
// $FlowExpectedError[prop-missing]
dependentSignal[ABORTED_KEY] = true;
// $FlowExpectedError[prop-missing]
dependentSignal[REASON_KEY] = reason;
unregisterDependentSignal(dependentSignal);
dependentSignalsToAbort.push(dependentSignal);
}
}
}

dispatchTrustedEvent(signal, new Event('abort'));
for (const dependentSignal of dependentSignalsToAbort) {
dispatchTrustedEvent(dependentSignal, new Event('abort'));
}
}

function unregisterDependentSignal(dependentSignal: AbortSignal): void {
const links = dependentSignalLinks.get(dependentSignal);
if (links == null) {
return;
}
dependentSignalLinks.delete(dependentSignal);
for (const sourceRef of links.sourceSignalRefs) {
const sourceSignal = sourceRef.deref();
if (sourceSignal != null) {
dependentSignalRefs.get(sourceSignal)?.delete(links.signalRef);
}
}
}

// Properties should be enumerable.
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -340,15 +340,93 @@ describe('AbortController', () => {
const second = new AbortController();
const reason = new Error('stop');

const signal = AbortSignal.any([first.signal, second.signal]);
Fantom.runTask(() => {
const signal = AbortSignal.any([first.signal, second.signal]);

expect(signal).toBeInstanceOf(AbortSignal);
expect(signal.aborted).toBe(false);
expect(signal).toBeInstanceOf(AbortSignal);
expect(signal.aborted).toBe(false);

second.abort(reason);
second.abort(reason);

expect(signal.aborted).toBe(true);
expect(signal.reason).toBe(reason);
expect(signal.aborted).toBe(true);
expect(signal.reason).toBe(reason);
});
});

it('should abort even if a source listener stops propagation', () => {
Fantom.runTask(() => {
const source = new AbortController();
source.signal.addEventListener('abort', event => {
event.stopImmediatePropagation();
});
const signal = AbortSignal.any([source.signal]);

source.abort('cancelled');

expect(signal.aborted).toBe(true);
expect(signal.reason).toBe('cancelled');
});
});

it('should mark dependent signals as aborted before dispatching to the source', () => {
Fantom.runTask(() => {
const source = new AbortController();
let observed;
source.signal.addEventListener('abort', () => {
observed = [signal.aborted, signal.reason];
});
const signal = AbortSignal.any([source.signal]);

source.abort('reason');

expect(observed).toEqual([true, 'reason']);
});
});

it('should dispatch to the source and then to its dependents in creation order', () => {
Fantom.runTask(() => {
const first = new AbortController();
const second = new AbortController();
const inner = AbortSignal.any([first.signal, second.signal]);
const outer = AbortSignal.any([inner, inner, first.signal]);
const unrelated = AbortSignal.any([second.signal]);
const events: Array<string> = [];
first.signal.addEventListener('abort', () => {
events.push('first');
});
inner.addEventListener('abort', () => {
events.push('inner');
});
outer.addEventListener('abort', () => {
events.push('outer');
});
unrelated.addEventListener('abort', () => {
events.push('unrelated');
});

first.abort('first reason');
second.abort('second reason');

expect(events).toEqual(['first', 'inner', 'outer', 'unrelated']);
expect(outer.reason).toBe('first reason');
expect(unrelated.reason).toBe('second reason');
});
});

it('should keep the first reason when a source listener aborts another source', () => {
Fantom.runTask(() => {
const first = new AbortController();
const second = new AbortController();
first.signal.addEventListener('abort', () => second.abort('second'));
const signal = AbortSignal.any([first.signal, second.signal]);
const listener = createListener();
signal.addEventListener('abort', listener);

first.abort('first');

expect(signal.reason).toBe('first');
expect(listener).toHaveBeenCalledTimes(1);
});
});

it('should abort immediately if one of the provided signals is already aborted', () => {
Expand Down
Loading