events: allow an event to be dispatched multiple times

Use a different flag to prevent recursive dispatching.
PR-URL: #39395
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: lpinca

lib/internal/event_target.js

@@ -47,6 +47,7 @@ const {
 }=EventEmitter;
 
 constkEvents=Symbol('kEvents');
+constkIsBeingDispatched=Symbol('kIsBeingDispatched');
 constkStop=Symbol('kStop');
 constkTarget=Symbol('kTarget');
 constkHandlers=Symbol('khandlers');
@@ -105,6 +106,7 @@ class Event {
 configurable: false
 });
 this[kTarget]=null;
+this[kIsBeingDispatched]=false;
 }
 
 [customInspectSymbol](depth,options){
@@ -151,12 +153,12 @@ class Event {
 // These are not supported in Node.js and are provided purely for
 // API completeness.
 
-composedPath(){returnthis[kTarget] ? [this[kTarget]] : [];}
+composedPath(){returnthis[kIsBeingDispatched] ? [this[kTarget]] : [];}
 getreturnValue(){return!this.defaultPrevented;}
 getbubbles(){returnthis[kBubbles];}
 getcomposed(){returnthis[kComposed];}
 geteventPhase(){
-returnthis[kTarget] ? Event.AT_TARGET : Event.NONE;
+returnthis[kIsBeingDispatched] ? Event.AT_TARGET : Event.NONE;
 }
 getcancelBubble(){returnthis[kPropagationStopped];}
 setcancelBubble(value){
@@ -397,7 +399,7 @@ class EventTarget {
 if(!isEventTarget(this))
 thrownewERR_INVALID_THIS('EventTarget');
 
-if(event[kTarget]!==null)
+if(event[kIsBeingDispatched])
 thrownewERR_EVENT_RECURSION(event.type);
 
 this[kHybridDispatch](event,event.type,event);
@@ -410,11 +412,14 @@ class EventTarget {
 if(event===undefined){
 event=this[kCreateEvent](nodeValue,type);
 event[kTarget]=this;
+event[kIsBeingDispatched]=true;
 }
 returnevent;
 };
-if(event!==undefined)
+if(event!==undefined){
 event[kTarget]=this;
+event[kIsBeingDispatched]=true;
+}
 
 constroot=this[kEvents].get(type);
 if(root===undefined||root.next===undefined)
@@ -453,6 +458,9 @@ class EventTarget {
 letresult;
 if(callback){
 result=FunctionPrototypeCall(callback,this,arg);
+if(!handler.isNodeStyleListener){
+arg[kIsBeingDispatched]=false;
+}
 }
 if(result!==undefined&&result!==null)
 addCatch(result);
@@ -464,7 +472,7 @@ class EventTarget {
 }
 
 if(event!==undefined)
-event[kTarget]=undefined;
+event[kIsBeingDispatched]=false;
 }
 
 [kCreateEvent](nodeValue,type){

test/parallel/test-eventtarget.js

@@ -162,6 +162,36 @@ let asyncTest = Promise.resolve();
 eventTarget.dispatchEvent(ev);
 }
 
+{
+// Same event dispatched multiple times.
+constevent=newEvent('foo');
+consteventTarget1=newEventTarget();
+consteventTarget2=newEventTarget();
+
+eventTarget1.addEventListener('foo',common.mustCall((event)=>{
+strictEqual(event.eventPhase,Event.AT_TARGET);
+strictEqual(event.target,eventTarget1);
+deepStrictEqual(event.composedPath(),[eventTarget1]);
+}));
+
+eventTarget2.addEventListener('foo',common.mustCall((event)=>{
+strictEqual(event.eventPhase,Event.AT_TARGET);
+strictEqual(event.target,eventTarget2);
+deepStrictEqual(event.composedPath(),[eventTarget2]);
+}));
+
+eventTarget1.dispatchEvent(event);
+strictEqual(event.eventPhase,Event.NONE);
+strictEqual(event.target,eventTarget1);
+deepStrictEqual(event.composedPath(),[]);
+
+
+eventTarget2.dispatchEvent(event);
+strictEqual(event.eventPhase,Event.NONE);
+strictEqual(event.target,eventTarget2);
+deepStrictEqual(event.composedPath(),[]);
+}
+
 {
 consteventTarget=newEventTarget();
 constevent=newEvent('foo',{cancelable: true});