pseudo-dom 0.1.0 → 0.3.0

package/dist/services/ElementService.d.ts

@@ -35,12 +35,13 @@ 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
      * @param {Array<{name: string, value: *}>} [settings.attributes=[]] The attributes (also assigned as properties) to start with
-     * @param {PseudoNode|null} [settings.parent=null] The parent node
-     * @param {Array} [settings.children=[]] The values or nodes to start as children
+     * @param {PseudoNode|null} [settings.parent=null] The node to add this element to as its last child
+     * @param {Array<PseudoNode>} [settings.children=[]] The nodes to start as children
      * @constructor
      */
     constructor({ tagName, attributes, parent, children }?: {
@@ -61,11 +62,10 @@ export declare class ElementService extends NodeService implements Partial<Pseud
      */
     applyDefaultEvent(): Function;
     /**
-     *
-     * @param {PseudoNode|ElementService} childElement
-     * @returns {PseudoNode}
+     * An element which is added as a child gets its default events (for example a submit button submits its form).
+     * @param {NodeService} child The node which was inserted
      */
-    appendChild(childElement: ElementService): PseudoNode;
+    protected childInserted(child: NodeService): void;
     /**
      * Check whether the element has an attribute by that name.
      * @param {string} attributeName

package/dist/services/ElementService.js

@@ -16,8 +16,7 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.ElementService = void 0
-const generateNodeList_1 = __importDefault(require('../factories/generateNodeList'))
-const TreeLinker_1 = require('collect-your-stuff/dist/collections/linked-tree-list/TreeLinker')
+const EventService_1 = require('./EventService')
 const NodeService_1 = require('./NodeService')
 const AttrService_1 = require('./AttrService')
 const DOMTokenListService_1 = require('./DOMTokenListService')
@@ -43,8 +42,8 @@ class ElementService extends NodeService_1.NodeService {
    * @param {Object} [settings={}]
    * @param {string} [settings.tagName=''] The name of the tag this element represents
    * @param {Array<{name: string, value: *}>} [settings.attributes=[]] The attributes (also assigned as properties) to start with
-   * @param {PseudoNode|null} [settings.parent=null] The parent node
-   * @param {Array} [settings.children=[]] The values or nodes to start as children
+   * @param {PseudoNode|null} [settings.parent=null] The node to add this element to as its last child
+   * @param {Array<PseudoNode>} [settings.children=[]] The nodes to start as children
    * @constructor
    */
   constructor ({
@@ -54,9 +53,8 @@ class ElementService extends NodeService_1.NodeService {
     children = []
   } = {}) {
     super()
+    this.defaultEventApplied = false
     this.tokenList = new DOMTokenListService_1.DOMTokenListService()
-    this.parent = parent
-    this.children = (0, generateNodeList_1.default)(TreeLinker_1.TreeLinker.fromArray(children).head)
     this.tag = tagName
     this.attributeList = attributes.concat([{
       name: 'className',
@@ -77,6 +75,15 @@ class ElementService extends NodeService_1.NodeService {
     }) => {
       this[name] = value
     })
+    children.forEach(child => {
+      if (!child || typeof child.nodeType !== 'number') {
+        throw new TypeError('The children of an element must be nodes.')
+      }
+      this.appendChild(child)
+    })
+    if (parent) {
+      parent.appendChild(this)
+    }
   }
 
   get tagName () {
@@ -112,34 +119,38 @@ 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
   }
 
   /**
-   *
-   * @param {PseudoNode|ElementService} childElement
-   * @returns {PseudoNode}
+   * An element which is added as a child gets its default events (for example a submit button submits its form).
+   * @param {NodeService} child The node which was inserted
    */
-  appendChild (childElement) {
-    super.appendChild(childElement)
-    childElement.applyDefaultEvent()
-    return childElement
+  childInserted (child) {
+    if (typeof child.applyDefaultEvent === 'function') {
+      child.applyDefaultEvent()
+    }
   }
 
   /**

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 generateNodeList_1=__importDefault(require("../factories/generateNodeList")),TreeLinker_1=require("collect-your-stuff/dist/collections/linked-tree-list/TreeLinker"),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.parent=r,this.children=(0,generateNodeList_1.default)(TreeLinker_1.TreeLinker.fromArray(i).head),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})}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}appendChild(e){return super.appendChild(e),e.applyDefaultEvent(),e}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;