diff --git a/packages/react-native/src/private/webapis/dom/abort-api/AbortSignal.js b/packages/react-native/src/private/webapis/dom/abort-api/AbortSignal.js index 7fc6e66616d..19cbb33cc68 100644 --- a/packages/react-native/src/private/webapis/dom/abort-api/AbortSignal.js +++ b/packages/react-native/src/private/webapis/dom/abort-api/AbortSignal.js @@ -42,6 +42,18 @@ import {AbortController} from './AbortController'; const ABORTED_KEY = Symbol('aborted'); const REASON_KEY = Symbol('reason'); +type DependentSignalLinks = { + readonly signalRef: WeakRef, + readonly sourceSignalRefs: ReadonlyArray>, +}; + +const dependentSignalRefs: WeakMap< + AbortSignal, + Set>, +> = new WeakMap(); +const dependentSignalLinks: WeakMap = + new WeakMap(); + /** * The signal class. * @see https://dom.spec.whatwg.org/#abortsignal @@ -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 = 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> = []; + 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; @@ -193,7 +224,44 @@ export function abortSignal( } signal[ABORTED_KEY] = true; signal[REASON_KEY] = reason; + + const dependentSignalsToAbort: Array = []; + 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. diff --git a/packages/react-native/src/private/webapis/dom/abort-api/__tests__/AbortController-itest.js b/packages/react-native/src/private/webapis/dom/abort-api/__tests__/AbortController-itest.js index 4f2a6dd60a4..25d6b2089e0 100644 --- a/packages/react-native/src/private/webapis/dom/abort-api/__tests__/AbortController-itest.js +++ b/packages/react-native/src/private/webapis/dom/abort-api/__tests__/AbortController-itest.js @@ -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 = []; + 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', () => {