pseudo-dom 0.2.0 → 0.3.0

package/dist/classes/PseudoEventListener.js

@@ -18,6 +18,13 @@ const EventService_1 = require('../services/EventService')
  * @property {boolean} isDefault
  */
 class PseudoEventListener {
+  /**
+   * @param {string} eventType The type of event this listens for
+   * @param {Object} [options] The capture, once and passive options
+   * @param {Function} handleEvent The function which is called with the event, already bound to what it should run as
+   * @param {Function} [originalCallback=handleEvent] The function (or object) which was given when registering, used to find this listener again
+   * @constructor
+   */
   constructor (eventType, {
     capture = false,
     once = false,
@@ -30,6 +37,7 @@ class PseudoEventListener {
     }
     this.eventType = ''
     this.defaultListener = false
+    this.isRemoved = false
     this.eventOptions = {
       capture,
       once,
@@ -47,6 +55,11 @@ class PseudoEventListener {
     return this.originalCallback
   }
 
+  /** Whether this listener listens in the capture phase (and at the target) rather than in the bubble phase. */
+  get capture () {
+    return this.eventOptions.capture
+  }
+
   get isDefault () {
     return this.defaultListener
   }
@@ -55,6 +68,20 @@ class PseudoEventListener {
     return this.eventOptions.once
   }
 
+  /** Whether the listener promises not to prevent the default (preventDefault does nothing while it runs). */
+  get passive () {
+    return this.eventOptions.passive
+  }
+
+  /** Whether this listener has been removed, a removed listener does not run even if the event already started. */
+  get removed () {
+    return this.isRemoved
+  }
+
+  set removed (removed) {
+    this.isRemoved = removed
+  }
+
   /**
    * @method
    * @name PseudoEventListener#handleEvent
@@ -66,6 +93,7 @@ class PseudoEventListener {
   }
 
   /**
+   * A capture listener runs while the event travels down to the target.
    * @method
    * @name PseudoEventListener#doCapturePhase
    * @param {PseudoEvent} event
@@ -76,6 +104,7 @@ class PseudoEventListener {
   }
 
   /**
+   * Every listener of the target itself runs, capture listeners first.
    * @method
    * @name PseudoEventListener#doTargetPhase
    * @param {PseudoEvent} event
@@ -86,13 +115,14 @@ class PseudoEventListener {
   }
 
   /**
+   * A listener which is not a capture listener runs while the event travels back up (when it bubbles).
    * @method
    * @name PseudoEventListener#doBubblePhase
    * @param {PseudoEvent} event
-   * @returns {boolean|*}
+   * @returns {boolean}
    */
   doBubblePhase (event) {
-    return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && (event.bubbles || !this.eventOptions.capture)
+    return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && !this.eventOptions.capture
   }
 
   /**
@@ -106,43 +136,16 @@ class PseudoEventListener {
   }
 
   /**
-   * @method
-   * @name PseudoEventListener#skipDefault
-   * @param {PseudoEvent} event
-   * @returns {boolean|*}
-   */
-  skipDefault (event) {
-    return this.isDefault && event.defaultPrevented
-  }
-
-  /**
-   * @method
-   * @name PseudoEventListener#stopPropagation
-   * @param {PseudoEvent} event
-   * @returns {boolean}
-   */
-  stopPropagation (event) {
-    return !this.doTargetPhase(event) && event.inner.propagationStopped
-  }
-
-  /**
-   * @method
-   * @name PseudoEventListener#nonPassiveHalt
-   * @param {PseudoEvent} event
-   * @returns {boolean|*}
-   */
-  nonPassiveHalt (event) {
-    return !this.eventOptions.passive && (this.skipDefault(event) || event.inner.immediatePropagationStopped || this.stopPropagation(event))
-  }
-
-  /**
+   * Whether this listener should not run for the event as it is now (it was removed, or it is for another phase).
+   * Stopping propagation is handled by the dispatching, since it stops other targets and not the listeners of the
+   * current one.
    * @method
    * @name PseudoEventListener#rejectEvent
    * @param {PseudoEvent} event
-   * @returns {*|boolean}
+   * @returns {boolean}
    */
   rejectEvent (event) {
-    return this.nonPassiveHalt(event) || this.skipPhase(event)
+    return this.isRemoved || this.skipPhase(event)
   }
 }
 exports.default = PseudoEventListener

package/dist/classes/PseudoEventListener.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const EventService_1=require("../services/EventService");class PseudoEventListener{constructor(e,{capture:t=!1,once:s=!1,passive:n=!1}={},i,r=i){this.eventOptions={capture:!1,once:!1,passive:!1},this.eventType="",this.defaultListener=!1,this.eventOptions={capture:t,once:s,passive:n},this.eventType=e,this.handler=i,this.originalCallback=r}get callback(){return this.originalCallback}get isDefault(){return this.defaultListener}get once(){return this.eventOptions.once}handleEvent(e){return this.handler(e)}doCapturePhase(e){return e.eventPhase===EventService_1.EventService.CAPTURING_PHASE&&this.eventOptions.capture}doTargetPhase(e){return e.eventPhase===EventService_1.EventService.AT_TARGET}doBubblePhase(e){return e.eventPhase===EventService_1.EventService.BUBBLING_PHASE&&(e.bubbles||!this.eventOptions.capture)}skipPhase(e){return!this.doCapturePhase(e)&&!this.doTargetPhase(e)&&!this.doBubblePhase(e)}skipDefault(e){return this.isDefault&&e.defaultPrevented}stopPropagation(e){return!this.doTargetPhase(e)&&e.inner.propagationStopped}nonPassiveHalt(e){return!this.eventOptions.passive&&(this.skipDefault(e)||e.inner.immediatePropagationStopped||this.stopPropagation(e))}rejectEvent(e){return this.nonPassiveHalt(e)||this.skipPhase(e)}}exports.default=PseudoEventListener;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const EventService_1=require("../services/EventService");class PseudoEventListener{constructor(e,{capture:t=!1,once:s=!1,passive:r=!1}={},i,n=i){this.eventOptions={capture:!1,once:!1,passive:!1},this.eventType="",this.defaultListener=!1,this.isRemoved=!1,this.eventOptions={capture:t,once:s,passive:r},this.eventType=e,this.handler=i,this.originalCallback=n}get callback(){return this.originalCallback}get capture(){return this.eventOptions.capture}get isDefault(){return this.defaultListener}get once(){return this.eventOptions.once}get passive(){return this.eventOptions.passive}get removed(){return this.isRemoved}set removed(e){this.isRemoved=e}handleEvent(e){return this.handler(e)}doCapturePhase(e){return e.eventPhase===EventService_1.EventService.CAPTURING_PHASE&&this.eventOptions.capture}doTargetPhase(e){return e.eventPhase===EventService_1.EventService.AT_TARGET}doBubblePhase(e){return e.eventPhase===EventService_1.EventService.BUBBLING_PHASE&&!this.eventOptions.capture}skipPhase(e){return!this.doCapturePhase(e)&&!this.doTargetPhase(e)&&!this.doBubblePhase(e)}rejectEvent(e){return this.isRemoved||this.skipPhase(e)}}exports.default=PseudoEventListener;

package/dist/interfaces/PseudoEventTarget.d.ts

@@ -35,12 +35,12 @@ export interface PseudoEventTarget {
      * @param {string} type
      * @param {function} callback
      */
-    removeEventListener(type: string, callback: Function): void;
+    removeEventListener(type: string, callback: Function, options?: listenerOptions | boolean): void;
     /**
      * Dispatches an event to this EventTarget.
      * @param {Event|PseudoEvent} event
      * @param {EventTarget|PseudoEventTarget} target
      * @returns {boolean}
      */
-    dispatchEvent(event: PseudoEvent, target: PseudoEventTarget): boolean;
+    dispatchEvent(event: PseudoEvent): boolean;
 }

package/dist/services/ElementService.d.ts

@@ -35,6 +35,7 @@ export declare class ElementService extends NodeService implements Partial<Pseud
     private readonly attributeList;
     private readonly propertyAttributes;
     private readonly tokenList;
+    private defaultEventApplied;
     /**
      * @param {Object} [settings={}]
      * @param {string} [settings.tagName=''] The name of the tag this element represents

package/dist/services/ElementService.js

@@ -16,6 +16,7 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.ElementService = void 0
+const EventService_1 = require('./EventService')
 const NodeService_1 = require('./NodeService')
 const AttrService_1 = require('./AttrService')
 const DOMTokenListService_1 = require('./DOMTokenListService')
@@ -52,6 +53,7 @@ class ElementService extends NodeService_1.NodeService {
     children = []
   } = {}) {
     super()
+    this.defaultEventApplied = false
     this.tokenList = new DOMTokenListService_1.DOMTokenListService()
     this.tag = tagName
     this.attributeList = attributes.concat([{
@@ -117,20 +119,25 @@ class ElementService extends NodeService_1.NodeService {
    */
   applyDefaultEvent () {
     let callback = event => undefined
+    if (this.defaultEventApplied) {
+      return callback
+    }
     switch (this.tagName) {
-      case 'form':
-        this.addEventListener('submit', callback)
-        break
       case 'button':
       case 'input':
         if (/^(submit|image)$/i.test(this.type || '')) {
+          // Clicking a submit button submits the form it is in: the form gets a submit event, which can be cancelled
           callback = event => {
             const forms = (0, getParentNodesFromAttribute_1.default)('tagName', 'form', this)
             if (forms.length) {
-              forms[0].submit()
+              forms[forms.length - 1].dispatchEvent(new EventService_1.EventService('submit', {
+                bubbles: true,
+                cancelable: true
+              }))
             }
           }
           super.setDefaultEvent('click', callback)
+          this.defaultEventApplied = true
         }
     }
     return callback

package/dist/services/ElementService.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.for-each.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.some.js");var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.ElementService=void 0;const NodeService_1=require("./NodeService"),AttrService_1=require("./AttrService"),DOMTokenListService_1=require("./DOMTokenListService"),NamedNodeMapService_1=require("./NamedNodeMapService"),getParentNodesFromAttribute_1=__importDefault(require("../functions/getParentNodesFromAttribute"));class ElementService extends NodeService_1.NodeService{constructor({tagName:e="",attributes:t=[],parent:r=null,children:i=[]}={}){super(),this.tokenList=new DOMTokenListService_1.DOMTokenListService,this.tag=e,this.attributeList=t.concat([{name:"className",value:""},{name:"id",value:""},{name:"innerHTML",value:""}]),this.propertyAttributes=this.attributeList.map(({name:e})=>e),this.attributeList.forEach(({name:e,value:t})=>{this[e]=t}),i.forEach(e=>{if(!e||"number"!=typeof e.nodeType)throw new TypeError("The children of an element must be nodes.");this.appendChild(e)}),r&&r.appendChild(this)}get tagName(){return this.tag}get nodeType(){return NodeService_1.NodeService.ELEMENT_NODE}get attributes(){return new NamedNodeMapService_1.NamedNodeMapService(this.attributeList.map(({name:e,value:t})=>new AttrService_1.AttrService(e,String(t),this)))}get classList(){return this.tokenList}get className(){return this.tokenList.value}set className(e){this.tokenList.value=e}applyDefaultEvent(){let e=e=>{};switch(this.tagName){case"form":this.addEventListener("submit",e);break;case"button":case"input":/^(submit|image)$/i.test(this.type||"")&&(e=e=>{const t=(0,getParentNodesFromAttribute_1.default)("tagName","form",this);t.length&&t[0].submit()},super.setDefaultEvent("click",e))}return e}childInserted(e){"function"==typeof e.applyDefaultEvent&&e.applyDefaultEvent()}hasAttribute(e){return this.attributeList.some(({name:t})=>t===e)}setAttribute(e,t){const r=this.attributeList.find(({name:t})=>t===e);r?r.value=t:this.attributeList.push({name:e,value:t}),this.propertyAttributes.indexOf(e)>=0&&(this[e]=t)}getAttribute(e){const t=this.attributeList.find(({name:t})=>t===e);return t?t.value:null}removeAttribute(e){const t=this.attributeList.findIndex(({name:t})=>t===e);t>=0&&this.attributeList.splice(t,1)}}exports.ElementService=ElementService;
+"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.for-each.js"),require("core-js/modules/esnext.iterator.map.js"),require("core-js/modules/esnext.iterator.some.js");var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.ElementService=void 0;const EventService_1=require("./EventService"),NodeService_1=require("./NodeService"),AttrService_1=require("./AttrService"),DOMTokenListService_1=require("./DOMTokenListService"),NamedNodeMapService_1=require("./NamedNodeMapService"),getParentNodesFromAttribute_1=__importDefault(require("../functions/getParentNodesFromAttribute"));class ElementService extends NodeService_1.NodeService{constructor({tagName:e="",attributes:t=[],parent:r=null,children:i=[]}={}){super(),this.defaultEventApplied=!1,this.tokenList=new DOMTokenListService_1.DOMTokenListService,this.tag=e,this.attributeList=t.concat([{name:"className",value:""},{name:"id",value:""},{name:"innerHTML",value:""}]),this.propertyAttributes=this.attributeList.map(({name:e})=>e),this.attributeList.forEach(({name:e,value:t})=>{this[e]=t}),i.forEach(e=>{if(!e||"number"!=typeof e.nodeType)throw new TypeError("The children of an element must be nodes.");this.appendChild(e)}),r&&r.appendChild(this)}get tagName(){return this.tag}get nodeType(){return NodeService_1.NodeService.ELEMENT_NODE}get attributes(){return new NamedNodeMapService_1.NamedNodeMapService(this.attributeList.map(({name:e,value:t})=>new AttrService_1.AttrService(e,String(t),this)))}get classList(){return this.tokenList}get className(){return this.tokenList.value}set className(e){this.tokenList.value=e}applyDefaultEvent(){let e=e=>{};if(this.defaultEventApplied)return e;switch(this.tagName){case"button":case"input":/^(submit|image)$/i.test(this.type||"")&&(e=e=>{const t=(0,getParentNodesFromAttribute_1.default)("tagName","form",this);t.length&&t[t.length-1].dispatchEvent(new EventService_1.EventService("submit",{bubbles:!0,cancelable:!0}))},super.setDefaultEvent("click",e),this.defaultEventApplied=!0)}return e}childInserted(e){"function"==typeof e.applyDefaultEvent&&e.applyDefaultEvent()}hasAttribute(e){return this.attributeList.some(({name:t})=>t===e)}setAttribute(e,t){const r=this.attributeList.find(({name:t})=>t===e);r?r.value=t:this.attributeList.push({name:e,value:t}),this.propertyAttributes.indexOf(e)>=0&&(this[e]=t)}getAttribute(e){const t=this.attributeList.find(({name:t})=>t===e);return t?t.value:null}removeAttribute(e){const t=this.attributeList.findIndex(({name:t})=>t===e);t>=0&&this.attributeList.splice(t,1)}}exports.ElementService=ElementService;

package/dist/services/EventService.d.ts

@@ -5,12 +5,24 @@
  */
 import { PseudoEventTarget } from '../interfaces/PseudoEventTarget';
 import { PseudoEvent } from '../interfaces/PseudoEvent';
+/**
+ * The parts of an event which the dispatching of it (EventTargetService) needs to change or read. Not part of the DOM's
+ * Event, which is why they are kept apart from the event's own properties.
+ */
 export type EventInner = {
-    currentTarget: PseudoEventTarget;
+    currentTarget: PseudoEventTarget | null;
     eventPhase: number;
     target: PseudoEventTarget;
     immediatePropagationStopped: boolean;
     propagationStopped: boolean;
+    /** True while the event is being dispatched. */
+    dispatching: boolean;
+    /** True while a passive listener is running, in which preventDefault does nothing. */
+    inPassiveListener: boolean;
+    /** The targets the event travels through, the target first and the root last, set while dispatching. */
+    path: Array<PseudoEventTarget>;
+    /** Finish the dispatch: no phase, no current target, no path and the stop flags are cleared so the event can be dispatched again. */
+    finishDispatch: () => void;
 };
 /**
  * Simulate the behaviour of the Event Class when there is no DOM available.
@@ -51,9 +63,9 @@ export declare class EventService implements PseudoEvent {
      *
      * @param {string} typeArg
      * @param {Object} [eventOptions={}]
-     * @param {boolean} [eventOptions.bubbles=true]
-     * @param {boolean} [eventOptions.cancelable=true]
-     * @param {boolean} [eventOptions.composed=true]
+     * @param {boolean} [eventOptions.bubbles=false]
+     * @param {boolean} [eventOptions.cancelable=false]
+     * @param {boolean} [eventOptions.composed=false]
      * @constructor
      */
     constructor(typeArg?: string, { bubbles, cancelable, composed }?: {

package/dist/services/EventService.js

@@ -5,18 +5,10 @@
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @version 1.0.0
  */
-const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-  return mod && mod.__esModule
-    ? mod
-    : {
-        default: mod
-      }
-}
 Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.EventService = void 0
-const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
 /**
  * Simulate the behaviour of the Event Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -51,20 +43,20 @@ class EventService {
    *
    * @param {string} typeArg
    * @param {Object} [eventOptions={}]
-   * @param {boolean} [eventOptions.bubbles=true]
-   * @param {boolean} [eventOptions.cancelable=true]
-   * @param {boolean} [eventOptions.composed=true]
+   * @param {boolean} [eventOptions.bubbles=false]
+   * @param {boolean} [eventOptions.cancelable=false]
+   * @param {boolean} [eventOptions.composed=false]
    * @constructor
    */
   constructor (typeArg = '', {
-    bubbles = true,
-    cancelable = true,
-    composed = true
+    bubbles = false,
+    cancelable = false,
+    composed = false
   } = {}) {
     this.properties = {
-      bubbles: true,
-      cancelable: true,
-      composed: true,
+      bubbles: false,
+      cancelable: false,
+      composed: false,
       currentTarget: null,
       defaultPrevented: false,
       immediatePropagationStopped: false,
@@ -73,7 +65,10 @@ class EventService {
       target: null,
       timeStamp: Math.floor(Date.now() / 1000),
       type: '',
-      isTrusted: true
+      isTrusted: true,
+      dispatching: false,
+      inPassiveListener: false,
+      path: []
     }
     this.setReadOnlyProperties({
       type: typeArg,
@@ -130,12 +125,21 @@ class EventService {
   get inner () {
     const self = this
     return {
+      get currentTarget () {
+        return self.properties.currentTarget
+      },
       set currentTarget (target) {
         self.properties.currentTarget = target
       },
+      get eventPhase () {
+        return self.properties.eventPhase
+      },
       set eventPhase (phase) {
         self.properties.eventPhase = phase
       },
+      get target () {
+        return self.properties.target
+      },
       set target (target) {
         self.properties.target = target
       },
@@ -144,6 +148,35 @@ class EventService {
       },
       get propagationStopped () {
         return self.properties.propagationStopped
+      },
+      get dispatching () {
+        return self.properties.dispatching
+      },
+      set dispatching (dispatching) {
+        self.properties.dispatching = dispatching
+      },
+      get inPassiveListener () {
+        return self.properties.inPassiveListener
+      },
+      set inPassiveListener (passive) {
+        self.properties.inPassiveListener = passive
+      },
+      get path () {
+        return self.properties.path
+      },
+      set path (path) {
+        self.properties.path = path
+      },
+      finishDispatch () {
+        self.setReadOnlyProperties({
+          currentTarget: null,
+          eventPhase: EventService.NONE,
+          path: [],
+          dispatching: false,
+          inPassiveListener: false,
+          propagationStopped: false,
+          immediatePropagationStopped: false
+        })
       }
     }
   }
@@ -154,16 +187,8 @@ class EventService {
    * @returns {Array.<PseudoEventTarget>}
    */
   composedPath () {
-    switch (this.eventPhase) {
-      case EventService.CAPTURING_PHASE:
-        return (0, getParentNodes_1.default)(this.target)
-      case EventService.BUBBLING_PHASE:
-        return (0, getParentNodes_1.default)(this.target).slice().reverse()
-      case EventService.AT_TARGET:
-        return [this.target]
-      default:
-        return []
-    }
+    // While the event is being dispatched this is every target it travels through, the target first and the root last
+    return this.properties.dispatching ? this.properties.path.slice() : []
   }
 
   /**
@@ -172,9 +197,12 @@ class EventService {
    * @returns {null}
    */
   preventDefault () {
-    this.setReadOnlyProperties({
-      defaultPrevented: true
-    })
+    // Only an event which can be cancelled can be prevented, and a passive listener cannot prevent the default
+    if (this.cancelable && !this.properties.inPassiveListener) {
+      this.setReadOnlyProperties({
+        defaultPrevented: true
+      })
+    }
     return null
   }
 

package/dist/services/EventService.min.js

@@ -1 +1 @@
-"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.EventService=void 0;const getParentNodes_1=__importDefault(require("../functions/getParentNodes"));class EventService{constructor(e="",{bubbles:t=!0,cancelable:r=!0,composed:s=!0}={}){this.properties={bubbles:!0,cancelable:!0,composed:!0,currentTarget:null,defaultPrevented:!1,immediatePropagationStopped:!1,propagationStopped:!1,eventPhase:0,target:null,timeStamp:Math.floor(Date.now()/1e3),type:"",isTrusted:!0},this.setReadOnlyProperties({type:e,bubbles:t,cancelable:r,composed:s})}get bubbles(){return this.properties.bubbles}get cancelable(){return this.properties.cancelable}get composed(){return this.properties.composed}get currentTarget(){return this.properties.currentTarget}get defaultPrevented(){return this.properties.defaultPrevented}get eventPhase(){return this.properties.eventPhase}get isTrusted(){return this.properties.isTrusted}get target(){return this.properties.target}get timeStamp(){return this.properties.timeStamp}get type(){return this.properties.type}get inner(){const e=this;return{set currentTarget(t){e.properties.currentTarget=t},set eventPhase(t){e.properties.eventPhase=t},set target(t){e.properties.target=t},get immediatePropagationStopped(){return e.properties.immediatePropagationStopped},get propagationStopped(){return e.properties.propagationStopped}}}composedPath(){switch(this.eventPhase){case EventService.CAPTURING_PHASE:return(0,getParentNodes_1.default)(this.target);case EventService.BUBBLING_PHASE:return(0,getParentNodes_1.default)(this.target).slice().reverse();case EventService.AT_TARGET:return[this.target];default:return[]}}preventDefault(){return this.setReadOnlyProperties({defaultPrevented:!0}),null}stopImmediatePropagation(){return this.setReadOnlyProperties({immediatePropagationStopped:!0}),null}stopPropagation(){return this.setReadOnlyProperties({propagationStopped:!0}),null}setReadOnlyProperties(e={}){return this.properties=Object.assign({},this.properties,e),this}}exports.EventService=EventService,EventService.NONE=0,EventService.CAPTURING_PHASE=1,EventService.AT_TARGET=2,EventService.BUBBLING_PHASE=3;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.EventService=void 0;class EventService{constructor(e="",{bubbles:t=!1,cancelable:r=!1,composed:i=!1}={}){this.properties={bubbles:!1,cancelable:!1,composed:!1,currentTarget:null,defaultPrevented:!1,immediatePropagationStopped:!1,propagationStopped:!1,eventPhase:0,target:null,timeStamp:Math.floor(Date.now()/1e3),type:"",isTrusted:!0,dispatching:!1,inPassiveListener:!1,path:[]},this.setReadOnlyProperties({type:e,bubbles:t,cancelable:r,composed:i})}get bubbles(){return this.properties.bubbles}get cancelable(){return this.properties.cancelable}get composed(){return this.properties.composed}get currentTarget(){return this.properties.currentTarget}get defaultPrevented(){return this.properties.defaultPrevented}get eventPhase(){return this.properties.eventPhase}get isTrusted(){return this.properties.isTrusted}get target(){return this.properties.target}get timeStamp(){return this.properties.timeStamp}get type(){return this.properties.type}get inner(){const e=this;return{get currentTarget(){return e.properties.currentTarget},set currentTarget(t){e.properties.currentTarget=t},get eventPhase(){return e.properties.eventPhase},set eventPhase(t){e.properties.eventPhase=t},get target(){return e.properties.target},set target(t){e.properties.target=t},get immediatePropagationStopped(){return e.properties.immediatePropagationStopped},get propagationStopped(){return e.properties.propagationStopped},get dispatching(){return e.properties.dispatching},set dispatching(t){e.properties.dispatching=t},get inPassiveListener(){return e.properties.inPassiveListener},set inPassiveListener(t){e.properties.inPassiveListener=t},get path(){return e.properties.path},set path(t){e.properties.path=t},finishDispatch(){e.setReadOnlyProperties({currentTarget:null,eventPhase:EventService.NONE,path:[],dispatching:!1,inPassiveListener:!1,propagationStopped:!1,immediatePropagationStopped:!1})}}}composedPath(){return this.properties.dispatching?this.properties.path.slice():[]}preventDefault(){return this.cancelable&&!this.properties.inPassiveListener&&this.setReadOnlyProperties({defaultPrevented:!0}),null}stopImmediatePropagation(){return this.setReadOnlyProperties({immediatePropagationStopped:!0}),null}stopPropagation(){return this.setReadOnlyProperties({propagationStopped:!0}),null}setReadOnlyProperties(e={}){return this.properties=Object.assign({},this.properties,e),this}}exports.EventService=EventService,EventService.NONE=0,EventService.CAPTURING_PHASE=1,EventService.AT_TARGET=2,EventService.BUBBLING_PHASE=3;

package/dist/services/EventTargetService.d.ts

@@ -7,6 +7,9 @@ import { EventService } from './EventService';
 import { listenerOptions, PseudoEventTarget } from '../interfaces/PseudoEventTarget';
 /**
  * Simulate the behaviour of the EventTarget Class when there is no DOM available.
+ * Dispatching an event sends it through the tree the way the DOM does: down from the root to the target (capture
+ * listeners), to the target itself, then back up to the root (the listeners which are not capture listeners, when the
+ * event bubbles).
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @class
  * @property {Object.<string, Array.<PseudoEventListener>>} listeners
@@ -28,25 +31,54 @@ declare class EventTargetService implements PseudoEventTarget {
      */
     private listenersFor;
     /**
-     * Run each of the listeners registered on this target for the type of the event.
-     * Listeners which do not apply to the event's phase are skipped, running stops once immediate propagation is stopped,
-     * and listeners added or removed while running do not change which ones run for this event.
-     * @param {EventService} event
-     * @returns {*} true when there was nothing registered, otherwise the last value returned from a handler (null when none ran)
+     * Run the listeners registered on this target for the type of the event which apply to the phase the event is in
+     * (at the target, the capture listeners run before the others). Listeners which are added while this runs do not run
+     * for this event, and listeners which are removed while it runs no longer do. Running stops as soon as immediate
+     * propagation is stopped. A listener which throws does not stop the others.
+     * @param {EventService} event The event, which is at a phase and has a current target
+     * @returns {Array<*>} The errors which the listeners threw
      */
     private runEvents;
+    /**
+     * Take a listener out of the registered listeners, so that it does not run again.
+     * @param {string} type
+     * @param {PseudoEventListener} listener
+     */
+    private removeListener;
     /**
      * Register the function to run when nothing else has prevented the default for this type of event.
      * @param {string} type
      * @param {Function} callback
      */
     protected setDefaultEvent(type: string, callback: Function): void;
-    private runDefaultEvent;
-    private startEvents;
+    /**
+     * Registers an event handler of a specific event type. Adding the same handler again for the same type and phase does
+     * nothing, like the DOM.
+     * @param {string} type The type of event to listen for
+     * @param {Function|Object} callback The function to call (or an object with a handleEvent function)
+     * @param {Object|boolean} [useCapture=false] Listen while the event travels down to the target (true), or an object with capture, once and passive
+     */
     addEventListener(type: string, callback: Function | {
         handleEvent: Function;
     } | any, useCapture?: listenerOptions | boolean): void;
-    removeEventListener(type: string, callback: Function): void;
-    dispatchEvent(event: EventService, target?: EventTargetService): boolean;
+    /**
+     * Removes an event listener, the one which was added with the same type, handler and phase.
+     * @param {string} type The type of event
+     * @param {Function|Object} callback The handler which was added
+     * @param {Object|boolean} [options=false] Whether the listener was a capture listener (true), or an object with capture
+     */
+    removeEventListener(type: string, callback: Function, options?: listenerOptions | boolean): void;
+    /**
+     * Dispatches an event to this target and through the tree: capture listeners of the ancestors from the root down,
+     * then the listeners of this target, then (when the event bubbles) the other listeners of the ancestors from the
+     * parent up to the root. stopPropagation() stops it reaching further targets, stopImmediatePropagation() also stops
+     * the remaining listeners of the current target. Afterwards, unless the default was prevented, the default action
+     * of this target (see setDefaultEvent) runs. The event can be dispatched again afterwards.
+     * @param {EventService} event The event to dispatch
+     * @returns {boolean} False when the event was cancelable and a listener prevented the default, otherwise true
+     * @throws {Error} When the event is already being dispatched, or (after the whole dispatch has finished) the error
+     * which a listener threw (an error with all of them in its errors property when several did)
+     */
+    dispatchEvent(event: EventService): boolean;
 }
 export default EventTargetService;