From decdf0dafc4e9193ea63170d2f1a2931c8f61b24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=BCrg=C3=BCn=20Day=C4=B1o=C4=9Flu?= Date: Sun, 15 Nov 2026 20:59:01 +0100 Subject: [PATCH] events: detach signal abort listener on listener removal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit addEventListener() with a signal registers an abort listener on the signal that was never removed when the event listener was removed by other means (removeEventListener(), a once listener firing, removeAllListeners(), weak listener cleanup). Every add/remove cycle on a long-lived signal left one more abort listener behind, slowing down later add/remove calls on that signal. Keep the abort listener and a weak reference to the signal on the Listener and detach it when the listener is removed. Assisted-by: claude:opus-5.5 Signed-off-by: Gürgün Dayıoğlu --- lib/internal/event_target.js | 43 +++++++++++++++---- ...est-eventtarget-signal-listener-cleanup.js | 25 +++++++++++ 2 files changed, 59 insertions(+), 9 deletions(-) create mode 100644 test/parallel/test-eventtarget-signal-listener-cleanup.js diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js index c5f104085132..5f450cd30701 100644 --- a/lib/internal/event_target.js +++ b/lib/internal/event_target.js @@ -461,7 +461,7 @@ const kFlagResistStopPropagation = 1 << 6; // slower. class Listener { constructor(eventTarget, eventType, previous, listener, once, capture, passive, - isNodeStyleListener, weak, resistStopPropagation) { + isNodeStyleListener, weak, resistStopPropagation, signal, onAbort) { this.next = undefined; if (previous !== undefined) previous.next = this; @@ -514,6 +514,8 @@ class Listener { }; this.listener = listener; } + this.signalRef = signal === undefined ? undefined : new SafeWeakRef(signal); + this.onAbort = onAbort; } get once() { @@ -556,6 +558,7 @@ class Listener { if (this.next !== undefined) this.next.previous = this.previous; this.flags |= kFlagRemoved; + this.detachSignal(); if ((this.flags & kFlagWeak) !== 0) { weakListeners().registry.unregister(this); const weakKey = this.weakKeyRef?.deref(); @@ -570,6 +573,19 @@ class Listener { } } } + + detachSignal() { + const onAbort = this.onAbort; + if (onAbort === undefined) + return; + this.onAbort = undefined; + this.signalRef.deref()?.removeEventListener('abort', onAbort); + } +} + +function detachSignals(root) { + for (let handler = root?.next; handler !== undefined; handler = handler.next) + handler.detachSignal(); } function initEventTarget(self) { @@ -646,6 +662,8 @@ class EventTarget { let isNodeStyleListener = false; let weak = false; let resistStopPropagation = false; + let signal; + let onAbort; // We flatten the options before the validateListener check because the // spec requires us to hit getters. @@ -656,7 +674,7 @@ class EventTarget { once = Boolean(options.once); capture = Boolean(options.capture); passive = Boolean(options.passive); - const signal = options.signal; + signal = options.signal; weak = options[kWeakHandler]; resistStopPropagation = options[kResistStopPropagation] ?? false; isNodeStyleListener = Boolean(options[kIsNodeStyleListener]); @@ -670,9 +688,11 @@ class EventTarget { // Capture a copy so that the closure doesn't move `capture` into the // function context, which slows down the listener lookup below. const removeCapture = capture; - signal.addEventListener('abort', () => { + onAbort = () => { this.removeEventListener(type, listener, removeCapture); - }, { __proto__: null, once: true, [kWeakHandler]: this, [kResistStopPropagation]: true }); + }; + signal.addEventListener('abort', onAbort, + { __proto__: null, once: true, [kWeakHandler]: this, [kResistStopPropagation]: true }); } } @@ -698,7 +718,7 @@ class EventTarget { root = { size: 1, next: undefined, resistStopPropagation: Boolean(resistStopPropagation) }; // This is the first handler in our linked list. new Listener(this, type, root, listener, once, capture, passive, - isNodeStyleListener, weak, resistStopPropagation); + isNodeStyleListener, weak, resistStopPropagation, signal, onAbort); this[kNewListener]( root.size, type, @@ -725,7 +745,7 @@ class EventTarget { } new Listener(this, type, previous, listener, once, capture, passive, - isNodeStyleListener, weak, resistStopPropagation); + isNodeStyleListener, weak, resistStopPropagation, signal, onAbort); root.size++; root.resistStopPropagation ||= Boolean(resistStopPropagation); this[kNewListener](root.size, type, listener, once, capture, passive, weak); @@ -1068,10 +1088,15 @@ class NodeEventTarget extends EventTarget { throw new ERR_INVALID_THIS('NodeEventTarget'); if (this[kEvents] === undefined) return this; - if (type !== undefined) - this[kEvents].delete(String(type)); - else + if (type !== undefined) { + type = String(type); + detachSignals(this[kEvents].get(type)); + this[kEvents].delete(type); + } else { + for (const { 1: root } of this[kEvents]) + detachSignals(root); this[kEvents].clear(); + } return this; } diff --git a/test/parallel/test-eventtarget-signal-listener-cleanup.js b/test/parallel/test-eventtarget-signal-listener-cleanup.js new file mode 100644 index 000000000000..239c25c7b59b --- /dev/null +++ b/test/parallel/test-eventtarget-signal-listener-cleanup.js @@ -0,0 +1,25 @@ +'use strict'; +const common = require('../common'); +const assert = require('node:assert'); +const { getEventListeners } = require('node:events'); + +const et = new EventTarget(); +const controller = new AbortController(); +const { signal } = controller; +const abortListeners = () => getEventListeners(signal, 'abort').length; + +function handler() {} + +et.addEventListener('foo', handler, { signal }); +et.removeEventListener('foo', handler); +assert.strictEqual(abortListeners(), 0); + +et.addEventListener('foo', common.mustCall(), { signal, once: true }); +et.dispatchEvent(new Event('foo')); +assert.strictEqual(abortListeners(), 0); + +et.addEventListener('foo', common.mustNotCall(), { signal }); +assert.strictEqual(abortListeners(), 1); +controller.abort(); +assert.strictEqual(abortListeners(), 0); +et.dispatchEvent(new Event('foo'));