pseudo-dom 0.2.0 → 0.4.0

package/dist/services/EventTargetService.js

@@ -4,6 +4,8 @@ require('core-js/modules/esnext.iterator.constructor.js')
 require('core-js/modules/esnext.iterator.filter.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')
 const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
   return mod && mod.__esModule
     ? mod
@@ -21,9 +23,13 @@ Object.defineProperty(exports, '__esModule', {
  */
 const EventService_1 = require('./EventService')
 const PseudoEventListener_1 = __importDefault(require('../classes/PseudoEventListener'))
+const getParentNodes_1 = __importDefault(require('../functions/getParentNodes'))
 const LinkedList_1 = require('collect-your-stuff/dist/collections/linked-list/LinkedList')
 /**
  * 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
@@ -53,33 +59,51 @@ class EventTargetService {
   }
 
   /**
-   * 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
    */
   runEvents (event) {
+    const errors = []
     if (!(event.type in this.listeners)) {
-      return true
+      return errors
     }
-    const listeners = this.listeners[event.type]
-    let eventReturn = null
-    // Work from a copy of the linkers so that removing a listener (for example a once listener) does not disturb the walk
-    for (const linker of Array.from(listeners)) {
-      const listener = linker.data
+    const listeners = Array.from(this.listeners[event.type]).map(linker => linker.data)
+    // At the target the capture listeners come first, otherwise the order is the order they were added
+    const ordered = event.eventPhase === EventService_1.EventService.AT_TARGET ? listeners.filter(listener => listener.capture).concat(listeners.filter(listener => !listener.capture)) : listeners
+    for (const listener of ordered) {
       if (event.inner.immediatePropagationStopped) {
         break
       }
       if (listener.rejectEvent(event)) {
         continue
       }
-      eventReturn = listener.handleEvent(event)
       if (listener.once) {
-        listeners.remove(linker)
+        this.removeListener(event.type, listener)
       }
+      event.inner.inPassiveListener = listener.passive
+      try {
+        listener.handleEvent(event)
+      } catch (error) {
+        errors.push(error)
+      }
+      event.inner.inPassiveListener = false
     }
-    return eventReturn
+    return errors
+  }
+
+  /**
+   * Take a listener out of the registered listeners, so that it does not run again.
+   * @param {string} type
+   * @param {PseudoEventListener} listener
+   */
+  removeListener (type, listener) {
+    listener.removed = true
+    const registered = this.listeners[type]
+    Array.from(registered).filter(linker => linker.data === listener).forEach(linker => registered.remove(linker))
   }
 
   /**
@@ -92,48 +116,34 @@ class EventTargetService {
     this.defaultEvent[type] = callback
   }
 
-  runDefaultEvent (event) {
-    if (event.defaultPrevented) {
-      return false
-    }
-    this.defaultEvent[event.type](event)
-    return true
-  }
-
-  startEvents (eventType) {
-    const event = new EventService_1.EventService(eventType)
-    event.inner.target = this;
-    [EventService_1.EventService.CAPTURING_PHASE, EventService_1.EventService.AT_TARGET, EventService_1.EventService.BUBBLING_PHASE].forEach(phase => {
-      let continueEvents = null
-      if (phase === EventService_1.EventService.AT_TARGET || !event.inner.propagationStopped) {
-        event.inner.eventPhase = phase
-        event.composedPath().forEach(target => {
-          event.inner.currentTarget = target
-          continueEvents = event.currentTarget.runEvents(event)
-        })
-      }
-      if (event.eventPhase === EventService_1.EventService.AT_TARGET && typeof continueEvents !== 'boolean' && this.defaultEvent[eventType]) {
-        this.runDefaultEvent(event)
-      }
-    })
-    return true
-  }
-
+  /**
+   * 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, callback, useCapture = false) {
     let options = {
       capture: false,
       once: false,
       passive: false
     }
-    if (typeof useCapture === 'object') {
+    if (typeof useCapture === 'object' && useCapture !== null) {
       // Originally useCapture was a single boolean flag, later optional other flags can be used
       // Here we take all the given flags from the object and assign them as the options
       options = Object.assign(options, useCapture)
     } else {
-      options.capture = useCapture
+      options.capture = !!useCapture
     }
-    const listener = new PseudoEventListener_1.default(type, options, (callback.handleEvent || callback).bind(this), callback)
     const listeners = this.listenersFor(type)
+    const alreadyAdded = Array.from(listeners).some(linker => linker.data.callback === callback && linker.data.capture === options.capture)
+    if (alreadyAdded) {
+      return
+    }
+    // A function runs with this target as this, an object runs its handleEvent as itself
+    const handler = typeof callback === 'function' ? callback.bind(this) : callback.handleEvent.bind(callback)
+    const listener = new PseudoEventListener_1.default(type, options, handler, callback)
     // Listeners run in the order they were added, except that listeners which are not defaults always come before the defaults
     const firstDefault = Array.from(listeners).find(linker => linker.data.isDefault)
     if (firstDefault && !listener.isDefault) {
@@ -143,20 +153,79 @@ class EventTargetService {
     }
   }
 
-  removeEventListener (type, callback) {
+  /**
+   * 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, callback, options = false) {
     if (!(type in this.listeners)) {
       return
     }
-    const listeners = this.listeners[type]
-    Array.from(listeners).filter(linker => !linker.data.isDefault && linker.data.callback === callback).forEach(linker => listeners.remove(linker))
+    const capture = typeof options === 'object' && options !== null ? !!options.capture : !!options
+    Array.from(this.listeners[type]).map(linker => linker.data).filter(listener => !listener.isDefault && listener.callback === callback && listener.capture === capture).forEach(listener => this.removeListener(type, listener))
   }
 
-  dispatchEvent (event, target = this) {
-    event.inner.target = target
-    if (!(event.type in this.listeners)) {
-      return true
+  /**
+   * 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) {
+    if (event.inner.dispatching) {
+      throw new Error('The event is already being dispatched.')
+    }
+    event.inner.dispatching = true
+    event.inner.target = this
+    // The ancestors, the root first, which can have listeners
+    const ancestors = (0, getParentNodes_1.default)(this).filter(node => node instanceof EventTargetService)
+    event.inner.path = [this].concat(ancestors.slice().reverse())
+    const errors = []
+    const visit = (target, phase) => {
+      event.inner.eventPhase = phase
+      event.inner.currentTarget = target
+      errors.push(...target.runEvents(event))
+    }
+    for (const ancestor of ancestors) {
+      if (event.inner.propagationStopped) {
+        break
+      }
+      visit(ancestor, EventService_1.EventService.CAPTURING_PHASE)
+    }
+    if (!event.inner.propagationStopped) {
+      visit(this, EventService_1.EventService.AT_TARGET)
+    }
+    if (event.bubbles) {
+      for (const ancestor of ancestors.slice().reverse()) {
+        if (event.inner.propagationStopped) {
+          break
+        }
+        visit(ancestor, EventService_1.EventService.BUBBLING_PHASE)
+      }
+    }
+    event.inner.finishDispatch()
+    if (!event.defaultPrevented && typeof this.defaultEvent[event.type] === 'function') {
+      try {
+        this.defaultEvent[event.type](event)
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+    if (errors.length === 1) {
+      throw errors[0]
+    }
+    if (errors.length > 1) {
+      throw Object.assign(new Error(`${errors.length} listeners threw an error while dispatching the ${event.type} event.`), {
+        errors
+      })
     }
-    this.runEvents(event)
     return !event.defaultPrevented
   }
 }

package/dist/services/EventTargetService.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.for-each.js");var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const EventService_1=require("./EventService"),PseudoEventListener_1=__importDefault(require("../classes/PseudoEventListener")),LinkedList_1=require("collect-your-stuff/dist/collections/linked-list/LinkedList");class EventTargetService{constructor(){this.listeners={},this.defaultEvent={}}listenersFor(e){return e in this.listeners||(this.listeners[e]=new LinkedList_1.LinkedList),this.listeners[e]}runEvents(e){if(!(e.type in this.listeners))return!0;const t=this.listeners[e.type];let r=null;for(const n of Array.from(t)){const s=n.data;if(e.inner.immediatePropagationStopped)break;s.rejectEvent(e)||(r=s.handleEvent(e),s.once&&t.remove(n))}return r}setDefaultEvent(e,t){this.listenersFor(e),this.defaultEvent[e]=t}runDefaultEvent(e){return!e.defaultPrevented&&(this.defaultEvent[e.type](e),!0)}startEvents(e){const t=new EventService_1.EventService(e);return t.inner.target=this,[EventService_1.EventService.CAPTURING_PHASE,EventService_1.EventService.AT_TARGET,EventService_1.EventService.BUBBLING_PHASE].forEach(r=>{let n=null;r!==EventService_1.EventService.AT_TARGET&&t.inner.propagationStopped||(t.inner.eventPhase=r,t.composedPath().forEach(e=>{t.inner.currentTarget=e,n=t.currentTarget.runEvents(t)})),t.eventPhase===EventService_1.EventService.AT_TARGET&&"boolean"!=typeof n&&this.defaultEvent[e]&&this.runDefaultEvent(t)}),!0}addEventListener(e,t,r=!1){let n={capture:!1,once:!1,passive:!1};"object"==typeof r?n=Object.assign(n,r):n.capture=r;const s=new PseudoEventListener_1.default(e,n,(t.handleEvent||t).bind(this),t),i=this.listenersFor(e),o=Array.from(i).find(e=>e.data.isDefault);o&&!s.isDefault?i.insertBefore(o,s):i.append(s)}removeEventListener(e,t){if(!(e in this.listeners))return;const r=this.listeners[e];Array.from(r).filter(e=>!e.data.isDefault&&e.data.callback===t).forEach(e=>r.remove(e))}dispatchEvent(e,t=this){return e.inner.target=t,!(e.type in this.listeners)||(this.runEvents(e),!e.defaultPrevented)}}exports.default=EventTargetService;
+"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.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});const EventService_1=require("./EventService"),PseudoEventListener_1=__importDefault(require("../classes/PseudoEventListener")),getParentNodes_1=__importDefault(require("../functions/getParentNodes")),LinkedList_1=require("collect-your-stuff/dist/collections/linked-list/LinkedList");class EventTargetService{constructor(){this.listeners={},this.defaultEvent={}}listenersFor(e){return e in this.listeners||(this.listeners[e]=new LinkedList_1.LinkedList),this.listeners[e]}runEvents(e){const t=[];if(!(e.type in this.listeners))return t;const r=Array.from(this.listeners[e.type]).map(e=>e.data),n=e.eventPhase===EventService_1.EventService.AT_TARGET?r.filter(e=>e.capture).concat(r.filter(e=>!e.capture)):r;for(const r of n){if(e.inner.immediatePropagationStopped)break;if(!r.rejectEvent(e)){r.once&&this.removeListener(e.type,r),e.inner.inPassiveListener=r.passive;try{r.handleEvent(e)}catch(e){t.push(e)}e.inner.inPassiveListener=!1}}return t}removeListener(e,t){t.removed=!0;const r=this.listeners[e];Array.from(r).filter(e=>e.data===t).forEach(e=>r.remove(e))}setDefaultEvent(e,t){this.listenersFor(e),this.defaultEvent[e]=t}addEventListener(e,t,r=!1){let n={capture:!1,once:!1,passive:!1};"object"==typeof r&&null!==r?n=Object.assign(n,r):n.capture=!!r;const i=this.listenersFor(e);if(Array.from(i).some(e=>e.data.callback===t&&e.data.capture===n.capture))return;const s="function"==typeof t?t.bind(this):t.handleEvent.bind(t),o=new PseudoEventListener_1.default(e,n,s,t),a=Array.from(i).find(e=>e.data.isDefault);a&&!o.isDefault?i.insertBefore(a,o):i.append(o)}removeEventListener(e,t,r=!1){if(!(e in this.listeners))return;const n="object"==typeof r&&null!==r?!!r.capture:!!r;Array.from(this.listeners[e]).map(e=>e.data).filter(e=>!e.isDefault&&e.callback===t&&e.capture===n).forEach(t=>this.removeListener(e,t))}dispatchEvent(e){if(e.inner.dispatching)throw new Error("The event is already being dispatched.");e.inner.dispatching=!0,e.inner.target=this;const t=(0,getParentNodes_1.default)(this).filter(e=>e instanceof EventTargetService);e.inner.path=[this].concat(t.slice().reverse());const r=[],n=(t,n)=>{e.inner.eventPhase=n,e.inner.currentTarget=t,r.push(...t.runEvents(e))};for(const r of t){if(e.inner.propagationStopped)break;n(r,EventService_1.EventService.CAPTURING_PHASE)}if(e.inner.propagationStopped||n(this,EventService_1.EventService.AT_TARGET),e.bubbles)for(const r of t.slice().reverse()){if(e.inner.propagationStopped)break;n(r,EventService_1.EventService.BUBBLING_PHASE)}if(e.inner.finishDispatch(),!e.defaultPrevented&&"function"==typeof this.defaultEvent[e.type])try{this.defaultEvent[e.type](e)}catch(e){r.push(e)}if(1===r.length)throw r[0];if(r.length>1)throw Object.assign(new Error(`${r.length} listeners threw an error while dispatching the ${e.type} event.`),{errors:r});return!e.defaultPrevented}}exports.default=EventTargetService;

package/dist/services/FocusEventService.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file Substitute for the DOM FocusEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { UIEventInit, UIEventService } from './UIEventService';
+import { PseudoEventTarget } from '../interfaces/PseudoEventTarget';
+/**
+ * The options for creating a focus event, on top of the ones every UI event has.
+ * @typedef {Object} FocusEventInit
+ * @property {PseudoEventTarget|null} [relatedTarget=null] The other target involved (the one losing or gaining the focus)
+ */
+export type FocusEventInit = UIEventInit & {
+    relatedTarget?: PseudoEventTarget | null;
+};
+/**
+ * Simulate the behaviour of the FocusEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {PseudoEventTarget|null} relatedTarget
+ */
+export declare class FocusEventService extends UIEventService {
+    private readonly related;
+    /**
+     * @param {string} [typeArg=''] The type of the event
+     * @param {FocusEventInit} [init={}] The options for the event
+     * @constructor
+     */
+    constructor(typeArg?: string, init?: FocusEventInit);
+    get relatedTarget(): PseudoEventTarget | null;
+}

package/dist/services/FocusEventService.js

@@ -0,0 +1,35 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.FocusEventService = void 0
+/**
+ * @file Substitute for the DOM FocusEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const UIEventService_1 = require('./UIEventService')
+/**
+ * Simulate the behaviour of the FocusEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {PseudoEventTarget|null} relatedTarget
+ */
+class FocusEventService extends UIEventService_1.UIEventService {
+  /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {FocusEventInit} [init={}] The options for the event
+   * @constructor
+   */
+  constructor (typeArg = '', init = {}) {
+    super(typeArg, init)
+    this.related = init.relatedTarget || null
+  }
+
+  get relatedTarget () {
+    return this.related
+  }
+}
+exports.FocusEventService = FocusEventService

package/dist/services/FocusEventService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.FocusEventService=void 0;const UIEventService_1=require("./UIEventService");class FocusEventService extends UIEventService_1.UIEventService{constructor(e="",t={}){super(e,t),this.related=t.relatedTarget||null}get relatedTarget(){return this.related}}exports.FocusEventService=FocusEventService;

package/dist/services/HTMLElementService.d.ts

@@ -34,4 +34,24 @@ export declare class HTMLElementService extends ElementService implements Partia
         parent?: PseudoNode | null;
         children?: Array<any>;
     });
+    /**
+     * Whether this element can have the focus: form controls and links which are not disabled, and anything with a tabindex.
+     * @returns {boolean}
+     */
+    get canFocus(): boolean;
+    /**
+     * Click the element: a click event is sent to it, which bubbles and can be cancelled, like one from a user but a
+     * script made it (so it is not trusted). A disabled element does nothing.
+     */
+    click(): void;
+    /**
+     * Give the element the focus. The element which had it gets blur then focusout, and this one gets focus then
+     * focusin (blur and focus do not bubble, focusin and focusout do). Nothing happens when the element cannot have the
+     * focus or already has it.
+     */
+    focus(): void;
+    /**
+     * Take the focus away from the element, when it has it: it gets blur then focusout.
+     */
+    blur(): void;
 }

package/dist/services/HTMLElementService.js

@@ -1,10 +1,19 @@
 'use strict'
 
+const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule
+    ? mod
+    : {
+        default: mod
+      }
+}
 Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.HTMLElementService = void 0
 const ElementService_1 = require('./ElementService')
+const createEvent_1 = __importDefault(require('../factories/createEvent'))
+const activeElement_1 = require('../functions/activeElement')
 /**
  * Simulate the behaviour of the HTMLElement Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -64,5 +73,91 @@ class HTMLElementService extends ElementService_1.ElementService {
       children
     })
   }
+
+  /**
+   * Whether this element can have the focus: form controls and links which are not disabled, and anything with a tabindex.
+   * @returns {boolean}
+   */
+  get canFocus () {
+    if (this.hasAttribute('disabled')) {
+      return false
+    }
+    switch (this.tagName) {
+      case 'button':
+      case 'select':
+      case 'textarea':
+        return true
+      case 'input':
+        return String(this.getAttribute('type') || '').toLowerCase() !== 'hidden'
+      case 'a':
+        return this.hasAttribute('href') || this.hasAttribute('tabindex')
+      default:
+        return this.hasAttribute('tabindex')
+    }
+  }
+
+  /**
+   * Click the element: a click event is sent to it, which bubbles and can be cancelled, like one from a user but a
+   * script made it (so it is not trusted). A disabled element does nothing.
+   */
+  click () {
+    if (this.hasAttribute('disabled')) {
+      return
+    }
+    this.dispatchEvent((0, createEvent_1.default)('click', {}, {
+      browser: true
+    }))
+  }
+
+  /**
+   * Give the element the focus. The element which had it gets blur then focusout, and this one gets focus then
+   * focusin (blur and focus do not bubble, focusin and focusout do). Nothing happens when the element cannot have the
+   * focus or already has it.
+   */
+  focus () {
+    const root = this.getRootNode()
+    const previous = (0, activeElement_1.getActiveElement)(root)
+    if (!this.canFocus || previous === this) {
+      return
+    }
+    const send = (target, type, relatedTarget) => {
+      target.dispatchEvent((0, createEvent_1.default)(type, {
+        relatedTarget
+      }, {
+        browser: true,
+        trusted: true
+      }))
+    }
+    if (previous) {
+      send(previous, 'blur', this)
+      send(previous, 'focusout', this)
+    }
+    (0, activeElement_1.setActiveElement)(root, this)
+    send(this, 'focus', previous)
+    send(this, 'focusin', previous)
+  }
+
+  /**
+   * Take the focus away from the element, when it has it: it gets blur then focusout.
+   */
+  blur () {
+    const root = this.getRootNode()
+    if ((0, activeElement_1.getActiveElement)(root) !== this) {
+      return
+    }
+    (0, activeElement_1.setActiveElement)(root, null)
+    this.dispatchEvent((0, createEvent_1.default)('blur', {
+      relatedTarget: null
+    }, {
+      browser: true,
+      trusted: true
+    }))
+    this.dispatchEvent((0, createEvent_1.default)('focusout', {
+      relatedTarget: null
+    }, {
+      browser: true,
+      trusted: true
+    }))
+  }
 }
 exports.HTMLElementService = HTMLElementService

package/dist/services/HTMLElementService.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.HTMLElementService=void 0;const ElementService_1=require("./ElementService");class HTMLElementService extends ElementService_1.ElementService{constructor({tagName:e="",parent:t=null,children:n=[]}={}){super({tagName:e,attributes:[{name:"hidden",value:!1},{name:"offsetHeight",value:0},{name:"offsetLeft",value:0},{name:"offsetParent",value:null},{name:"offsetTop",value:0},{name:"offsetWidth",value:0},{name:"style",value:{}},{name:"title",value:""}],parent:t,children:n})}}exports.HTMLElementService=HTMLElementService;
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.HTMLElementService=void 0;const ElementService_1=require("./ElementService"),createEvent_1=__importDefault(require("../factories/createEvent")),activeElement_1=require("../functions/activeElement");class HTMLElementService extends ElementService_1.ElementService{constructor({tagName:e="",parent:t=null,children:r=[]}={}){super({tagName:e,attributes:[{name:"hidden",value:!1},{name:"offsetHeight",value:0},{name:"offsetLeft",value:0},{name:"offsetParent",value:null},{name:"offsetTop",value:0},{name:"offsetWidth",value:0},{name:"style",value:{}},{name:"title",value:""}],parent:t,children:r})}get canFocus(){if(this.hasAttribute("disabled"))return!1;switch(this.tagName){case"button":case"select":case"textarea":return!0;case"input":return"hidden"!==String(this.getAttribute("type")||"").toLowerCase();case"a":return this.hasAttribute("href")||this.hasAttribute("tabindex");default:return this.hasAttribute("tabindex")}}click(){this.hasAttribute("disabled")||this.dispatchEvent((0,createEvent_1.default)("click",{},{browser:!0}))}focus(){const e=this.getRootNode(),t=(0,activeElement_1.getActiveElement)(e);if(!this.canFocus||t===this)return;const r=(e,t,r)=>{e.dispatchEvent((0,createEvent_1.default)(t,{relatedTarget:r},{browser:!0,trusted:!0}))};t&&(r(t,"blur",this),r(t,"focusout",this)),(0,activeElement_1.setActiveElement)(e,this),r(this,"focus",t),r(this,"focusin",t)}blur(){const e=this.getRootNode();(0,activeElement_1.getActiveElement)(e)===this&&((0,activeElement_1.setActiveElement)(e,null),this.dispatchEvent((0,createEvent_1.default)("blur",{relatedTarget:null},{browser:!0,trusted:!0})),this.dispatchEvent((0,createEvent_1.default)("focusout",{relatedTarget:null},{browser:!0,trusted:!0})))}}exports.HTMLElementService=HTMLElementService;

package/dist/services/InputEventService.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @file Substitute for the DOM InputEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { UIEventInit, UIEventService } from './UIEventService';
+/**
+ * The options for creating an input event, on top of the ones every UI event has.
+ * @typedef {Object} InputEventInit
+ * @property {string|null} [data=null] The characters which were entered
+ * @property {string} [inputType=''] What kind of change it was, such as insertText
+ * @property {boolean} [isComposing=false]
+ */
+export type InputEventInit = UIEventInit & {
+    data?: string | null;
+    inputType?: string;
+    isComposing?: boolean;
+};
+/**
+ * Simulate the behaviour of the InputEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string|null} data
+ * @property {string} inputType
+ * @property {boolean} isComposing
+ */
+export declare class InputEventService extends UIEventService {
+    private readonly inputData;
+    private readonly kind;
+    private readonly composing;
+    /**
+     * @param {string} [typeArg=''] The type of the event
+     * @param {InputEventInit} [init={}] The options for the event
+     * @constructor
+     */
+    constructor(typeArg?: string, init?: InputEventInit);
+    get data(): string | null;
+    get inputType(): string;
+    get isComposing(): boolean;
+}

package/dist/services/InputEventService.js

@@ -0,0 +1,47 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.InputEventService = void 0
+/**
+ * @file Substitute for the DOM InputEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const UIEventService_1 = require('./UIEventService')
+/**
+ * Simulate the behaviour of the InputEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string|null} data
+ * @property {string} inputType
+ * @property {boolean} isComposing
+ */
+class InputEventService extends UIEventService_1.UIEventService {
+  /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {InputEventInit} [init={}] The options for the event
+   * @constructor
+   */
+  constructor (typeArg = '', init = {}) {
+    super(typeArg, init)
+    this.inputData = typeof init.data === 'string' ? init.data : null
+    this.kind = init.inputType || ''
+    this.composing = !!init.isComposing
+  }
+
+  get data () {
+    return this.inputData
+  }
+
+  get inputType () {
+    return this.kind
+  }
+
+  get isComposing () {
+    return this.composing
+  }
+}
+exports.InputEventService = InputEventService

package/dist/services/InputEventService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.InputEventService=void 0;const UIEventService_1=require("./UIEventService");class InputEventService extends UIEventService_1.UIEventService{constructor(e="",t={}){super(e,t),this.inputData="string"==typeof t.data?t.data:null,this.kind=t.inputType||"",this.composing=!!t.isComposing}get data(){return this.inputData}get inputType(){return this.kind}get isComposing(){return this.composing}}exports.InputEventService=InputEventService;

package/dist/services/KeyboardEventService.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @file Substitute for the DOM KeyboardEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { UIEventInit, UIEventService } from './UIEventService';
+/**
+ * The options for creating a keyboard event, on top of the ones every UI event has.
+ * @typedef {Object} KeyboardEventInit
+ * @property {string} [key=''] The value of the key, such as a or Enter
+ * @property {string} [code=''] The physical key, such as KeyA or Enter
+ * @property {number} [location=0] Where on the keyboard the key is (0 standard, 1 left, 2 right, 3 numeric pad)
+ * @property {boolean} [repeat=false] The key is being held down
+ * @property {boolean} [isComposing=false]
+ * @property {boolean} [ctrlKey=false]
+ * @property {boolean} [shiftKey=false]
+ * @property {boolean} [altKey=false]
+ * @property {boolean} [metaKey=false]
+ */
+export type KeyboardEventInit = UIEventInit & {
+    key?: string;
+    code?: string;
+    location?: number;
+    repeat?: boolean;
+    isComposing?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+};
+/**
+ * Simulate the behaviour of the KeyboardEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string} key
+ * @property {string} code
+ * @property {number} location
+ * @property {boolean} repeat
+ * @property {boolean} isComposing
+ */
+export declare class KeyboardEventService extends UIEventService {
+    private readonly keyValue;
+    private readonly keyCode;
+    private readonly keyLocation;
+    private readonly held;
+    private readonly composing;
+    private readonly modifiers;
+    /**
+     * @param {string} [typeArg=''] The type of the event
+     * @param {KeyboardEventInit} [init={}] The options for the event
+     * @constructor
+     */
+    constructor(typeArg?: string, init?: KeyboardEventInit);
+    get key(): string;
+    get code(): string;
+    get location(): number;
+    get repeat(): boolean;
+    get isComposing(): boolean;
+    get ctrlKey(): boolean;
+    get shiftKey(): boolean;
+    get altKey(): boolean;
+    get metaKey(): boolean;
+    /**
+     * Whether a modifier key was held down when the event happened.
+     * @param {string} key Control, Shift, Alt or Meta
+     * @returns {boolean}
+     */
+    getModifierState(key: string): boolean;
+}