lib: add option to force handling stopped events

Author: atlowChemi

lib/events.js

@@ -61,6 +61,7 @@ const{
 letspliceOne;
 letFixedQueue;
 letkFirstEventParam;
+letkResistStopPropagation;
 
 const{
  AbortError,
@@ -978,7 +979,10 @@ async function once(emitter, name, options = kEmptyObject){
 }
 resolve(args);
 };
-eventTargetAgnosticAddListener(emitter,name,resolver,{once: true});
+
+kResistStopPropagation??=require('internal/event_target').kResistStopPropagation;
+constopts={__proto__: null,once: true,[kResistStopPropagation]: true};
+eventTargetAgnosticAddListener(emitter,name,resolver,opts);
 if(name!=='error'&&typeofemitter.once==='function'){
 // EventTarget does not have `error` event semantics like Node
 // EventEmitters, we listen to `error` events only on EventEmitters.
@@ -991,7 +995,7 @@ async function once(emitter, name, options = kEmptyObject){
 }
 if(signal!=null){
 eventTargetAgnosticAddListener(
-signal,'abort',abortListener,{once: true});
+signal,'abort',abortListener,{__proto__: null,once: true,[kResistStopPropagation]: true});
 }
 });
 }
@@ -1149,11 +1153,12 @@ function on(emitter, event, options = kEmptyObject){
 }
 }
 if(signal){
+kResistStopPropagation??=require('internal/event_target').kResistStopPropagation;
 eventTargetAgnosticAddListener(
 signal,
 'abort',
 abortListener,
-{once: true});
+{__proto__: null,once: true,[kResistStopPropagation]: true});
 }
 
 returniterator;

lib/internal/event_target.js

@@ -59,6 +59,7 @@ const kStop = Symbol('kStop');
 constkTarget=Symbol('kTarget');
 constkHandlers=Symbol('kHandlers');
 constkWeakHandler=Symbol('kWeak');
+constkResistStopPropagation=Symbol('kResistStopPropagation');
 
 constkHybridDispatch=SymbolFor('nodejs.internal.kHybridDispatch');
 constkCreateEvent=Symbol('kCreateEvent');
@@ -421,6 +422,7 @@ const kFlagPassive = 1 << 2;
 constkFlagNodeStyle=1<<3;
 constkFlagWeak=1<<4;
 constkFlagRemoved=1<<5;
+constkFlagResistStopPropagation=1<<6;
 
 // The listeners for an EventTarget are maintained as a linked list.
 // Unfortunately, the way EventTarget is defined, listeners are accounted
@@ -431,7 +433,7 @@ const kFlagRemoved = 1 << 5;
 // slower.
 classListener{
 constructor(previous,listener,once,capture,passive,
-isNodeStyleListener,weak){
+isNodeStyleListener,weak,resistStopPropagation){
 this.next=undefined;
 if(previous!==undefined)
 previous.next=this;
@@ -449,6 +451,8 @@ class Listener{
 flags|=kFlagNodeStyle;
 if(weak)
 flags|=kFlagWeak;
+if(resistStopPropagation)
+flags|=kFlagResistStopPropagation;
 this.flags=flags;
 
 this.removed=false;
@@ -486,6 +490,9 @@ class Listener{
 getweak(){
 returnBoolean(this.flags&kFlagWeak);
 }
+getresistStopPropagation(){
+returnBoolean(this.flags&kFlagResistStopPropagation);
+}
 getremoved(){
 returnBoolean(this.flags&kFlagRemoved);
 }
@@ -583,6 +590,7 @@ class EventTarget{
  signal,
  isNodeStyleListener,
  weak,
+ resistStopPropagation,
 }=validateEventListenerOptions(options);
 
 validateAbortSignal(signal,'options.signal');
@@ -609,16 +617,16 @@ class EventTarget{
 // not prevent the event target from GC.
 signal.addEventListener('abort',()=>{
 this.removeEventListener(type,listener,options);
-},{once: true,[kWeakHandler]: this});
+},{__proto__: null,once: true,[kWeakHandler]: this,[kResistStopPropagation]: true});
 }
 
 letroot=this[kEvents].get(type);
 
 if(root===undefined){
-root={size: 1,next: undefined};
+root={size: 1,next: undefined,resistStopPropagation: Boolean(resistStopPropagation)};
 // This is the first handler in our linked list.
 newListener(root,listener,once,capture,passive,
-isNodeStyleListener,weak);
+isNodeStyleListener,weak,resistStopPropagation);
 this[kNewListener](
 root.size,
 type,
@@ -645,8 +653,9 @@ class EventTarget{
 }
 
 newListener(previous,listener,once,capture,passive,
-isNodeStyleListener,weak);
+isNodeStyleListener,weak,resistStopPropagation);
 root.size++;
+root.resistStopPropagation||=Boolean(resistStopPropagation);
 this[kNewListener](root.size,type,listener,once,capture,passive,weak);
 }
 
@@ -730,14 +739,21 @@ class EventTarget{
 lethandler=root.next;
 letnext;
 
-while(handler!==undefined&&
-(handler.passive||event?.[kStop]!==true)){
+constiterationCondition=()=>{
+if(root.resistStopPropagation){
+returnhandler!==undefined;
+}
+returnhandler!==undefined&&(handler.passive||event?.[kStop]!==true);
+};
+while(iterationCondition()){
 // Cache the next item in case this iteration removes the current one
 next=handler.next;
 
-if(handler.removed){
+if(handler.removed||(event?.[kStop]===true&&!handler.resistStopPropagation)){
 // Deal with the case an event is removed while event handlers are
 // Being processed (removeEventListener called from a listener)
+// And the case of event.stopImmediatePropagation() being called
+// For events not flagged as resistStopPropagation
 handler=next;
 continue;
 }
@@ -1005,6 +1021,7 @@ function validateEventListenerOptions(options){
 passive: Boolean(options.passive),
 signal: options.signal,
 weak: options[kWeakHandler],
+resistStopPropagation: options[kResistStopPropagation]??false,
 isNodeStyleListener: Boolean(options[kIsNodeStyleListener]),
 };
 }
@@ -1132,5 +1149,6 @@ module.exports ={
  kRemoveListener,
  kEvents,
  kWeakHandler,
+ kResistStopPropagation,
  isEventTarget,
 };

test/parallel/test-events-once.js

@@ -233,6 +233,18 @@ async function eventTargetAbortSignalBefore(){
 });
 }
 
+asyncfunctioneventTargetAbortSignalBeforeEvenWhenSignalPropagationStopped(){
+constet=newEventTarget();
+constac=newAbortController();
+const{ signal }=ac;
+signal.addEventListener('abort',(e)=>e.stopImmediatePropagation(),{once: true});
+
+process.nextTick(()=>ac.abort());
+returnrejects(once(et,'foo',{ signal }),{
+name: 'AbortError',
+});
+}
+
 asyncfunctioneventTargetAbortSignalAfter(){
 constet=newEventTarget();
 constac=newAbortController();
@@ -270,6 +282,7 @@ Promise.all([
 abortSignalAfterEvent(),
 abortSignalRemoveListener(),
 eventTargetAbortSignalBefore(),
+eventTargetAbortSignalBeforeEvenWhenSignalPropagationStopped(),
 eventTargetAbortSignalAfter(),
 eventTargetAbortSignalAfterEvent(),
 ]).then(common.mustCall());

test/parallel/test-eventtarget.js

@@ -726,3 +726,15 @@ let asyncTest = Promise.resolve();
 et.removeEventListener(Symbol('symbol'),()=>{});
 },TypeError);
 }
+
+{
+// Test that event listeners are removed by signal even when
+// signal's abort event propagation stopped
+constcontroller=newAbortController();
+const{ signal }=controller;
+signal.addEventListener('abort',(e)=>e.stopImmediatePropagation(),{once: true});
+constet=newEventTarget();
+et.addEventListener('foo',common.mustNotCall(),{ signal });
+controller.abort();
+et.dispatchEvent(newEvent('foo'));
+}