pseudo-dom 0.17.0 → 1.0.0

package/dist/services/EventService.js

@@ -1,9 +1,7 @@
 'use strict'
 
 /**
- * @file Substitute for the DOM Event Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM Event Class.
  */
 Object.defineProperty(exports, '__esModule', {
   value: true
@@ -11,42 +9,15 @@ Object.defineProperty(exports, '__esModule', {
 exports.EventService = void 0
 /**
  * Simulate the behaviour of the Event Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @property {number} NONE
- * @property {number} CAPTURING_PHASE
- * @property {number} AT_TARGET
- * @property {number} BUBBLING_PHASE
- * @property {boolean} bubbles - A Boolean indicating whether the event bubbles up through the Dom or not.
- * @property {boolean} cancelable - A Boolean indicating whether the event is cancelable.
- * @property {boolean} composed - A Boolean value indicating whether the event can bubble across the boundary
- * between the shadow Dom and the regular Dom.
- * @property {function|PseudoEventTarget} currentTarget - A reference to the currently registered target for the event. This
- * is the object to which the event is currently slated to be sent; it's possible this has been changed along the way
- * through re-targeting.
- * @property {boolean} defaultPrevented - Indicates whether event.preventDefault() has been called on the event.
- * @property {boolean} immediatePropagationStopped - Flag that no further propagation should occur, including on current
- * target.
- * @property {boolean} propagationStopped - Flag that no further propagation should occur.
- * @property {int} eventPhase - Indicates which phase of the event flow is being processed. Uses EventService constants.
- * @property {EventTarget|PseudoEventTarget} target - A reference to the target to which the event was originally
- * dispatched.
- * @property {int} timeStamp - The time at which the event was created (in milliseconds). By specification, this
- * value is time since epoch, but in reality browsers' definitions vary; in addition, work is underway to change this
- * to be a DomHighResTimeStamp instead.
- * @property {string} type - The name of the event (case-insensitive).
- * @property {boolean} isTrusted - Indicates whether the event was initiated by the browser (after a user
- * click for instance) or by a script (using an event creation method, like event.initEvent)
  */
 class EventService {
   /**
    *
-   * @param {string} typeArg
-   * @param {Object} [eventOptions={}]
-   * @param {boolean} [eventOptions.bubbles=false]
-   * @param {boolean} [eventOptions.cancelable=false]
-   * @param {boolean} [eventOptions.composed=false]
-   * @constructor
+   * @param typeArg
+   * @param eventOptions
+   * @param eventOptions.bubbles
+   * @param eventOptions.cancelable
+   * @param eventOptions.composed
    */
   constructor (typeArg = '', {
     bubbles = false,
@@ -54,17 +25,29 @@ class EventService {
     composed = false
   } = {}) {
     this.properties = {
+      /** A Boolean indicating whether the event bubbles up through the Dom or not. */
       bubbles: false,
+      /** A Boolean indicating whether the event is cancelable. */
       cancelable: false,
+      /** A Boolean value indicating whether the event can bubble across the boundary between the shadow Dom and the regular Dom. */
       composed: false,
+      /** A reference to the currently registered target for the event. This is the object to which the event is currently slated to be sent; it's possible this has been changed along the way through re-targeting. */
       currentTarget: null,
+      /** Indicates whether event.preventDefault() has been called on the event. */
       defaultPrevented: false,
+      /** Flag that no further propagation should occur, including on current target. */
       immediatePropagationStopped: false,
+      /** Flag that no further propagation should occur. */
       propagationStopped: false,
+      /** Indicates which phase of the event flow is being processed. Uses EventService constants. */
       eventPhase: 0,
+      /** A reference to the target to which the event was originally dispatched. */
       target: null,
+      /** The time at which the event was created (in milliseconds). By specification, this value is time since epoch, but in reality browsers' definitions vary; in addition, work is underway to change this to be a DomHighResTimeStamp instead. */
       timeStamp: Math.floor(Date.now() / 1000),
+      /** The name of the event (case-insensitive). */
       type: '',
+      /** Indicates whether the event was initiated by the browser (after a user click for instance) or by a script (using an event creation method, like event.initEvent) */
       isTrusted: false,
       dispatching: false,
       inPassiveListener: false,
@@ -120,7 +103,6 @@ class EventService {
 
   /**
    * Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
-   * @returns {EventInner}
    */
   get inner () {
     const self = this
@@ -189,8 +171,6 @@ class EventService {
 
   /**
    * Return an array of targets that will have the event executed open them. The order is based on the eventPhase
-   * @method
-   * @returns {Array.<PseudoEventTarget>}
    */
   composedPath () {
     // While the event is being dispatched this is every target it travels through, the target first and the root last
@@ -199,8 +179,6 @@ class EventService {
 
   /**
    * Cancels the event (if it is cancelable).
-   * @method
-   * @returns {null}
    */
   preventDefault () {
     // Only an event which can be cancelled can be prevented, and a passive listener cannot prevent the default
@@ -216,8 +194,6 @@ class EventService {
    * For this particular event, no other listener will be called.
    * Neither those attached on the same element, nor those attached on elements which will be traversed later (in
    * capture phase, for instance)
-   * @method
-   * @returns {null}
    */
   stopImmediatePropagation () {
     this.setReadOnlyProperties({
@@ -228,8 +204,6 @@ class EventService {
 
   /**
    * Stops the propagation of events further along in the Dom.
-   * @method
-   * @returns {null}
    */
   stopPropagation () {
     this.setReadOnlyProperties({

package/dist/services/EventTargetService.d.ts

@@ -1,7 +1,5 @@
 /**
- * @file Substitute for the DOM EventTarget Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM EventTarget Class.
  */
 import { EventService } from './EventService';
 import { listenerOptions, PseudoEventTarget } from '../interfaces/PseudoEventTarget';
@@ -10,24 +8,14 @@ import { listenerOptions, PseudoEventTarget } from '../interfaces/PseudoEventTar
  * 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
- * @property {function} addEventListener
- * @property {function} removeEventListener
- * @property {function} dispatchEvent
  */
 declare class EventTargetService implements PseudoEventTarget {
     private readonly listeners;
     private readonly defaultEvent;
-    /**
-     * @constructor
-     */
     constructor();
     /**
      * The listeners registered for a type of event, creating the (empty) list of them when there are none yet.
-     * @param {string} type
-     * @returns {LinkedList}
+     * @param type
      */
     private listenersFor;
     /**
@@ -35,37 +23,37 @@ declare class EventTargetService implements PseudoEventTarget {
      * (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
+     * @param event The event, which is at a phase and has a current target
+     * @returns 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
+     * @param type
+     * @param 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
+     * @param type
+     * @param callback
      */
     protected setDefaultEvent(type: string, callback: Function): void;
     /**
      * 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
+     * @param type The type of event to listen for
+     * @param callback The function to call (or an object with a handleEvent function)
+     * @param useCapture 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;
     /**
      * 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
+     * @param type The type of event
+     * @param callback The handler which was added
+     * @param options Whether the listener was a capture listener (true), or an object with capture
      */
     removeEventListener(type: string, callback: Function, options?: listenerOptions | boolean): void;
     /**
@@ -74,8 +62,8 @@ declare class EventTargetService implements PseudoEventTarget {
      * 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
+     * @param event The event to dispatch
+     * @returns 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)
      */

package/dist/services/EventTargetService.js

@@ -17,9 +17,7 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 /**
- * @file Substitute for the DOM EventTarget Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM EventTarget Class.
  */
 const EventService_1 = require('./EventService')
 const PseudoEventListener_1 = __importDefault(require('../classes/PseudoEventListener'))
@@ -30,17 +28,8 @@ const LinkedList_1 = require('collect-your-stuff/dist/collections/linked-list/Li
  * 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
- * @property {function} addEventListener
- * @property {function} removeEventListener
- * @property {function} dispatchEvent
  */
 class EventTargetService {
-  /**
-   * @constructor
-   */
   constructor () {
     this.listeners = {}
     this.defaultEvent = {}
@@ -48,8 +37,7 @@ class EventTargetService {
 
   /**
    * The listeners registered for a type of event, creating the (empty) list of them when there are none yet.
-   * @param {string} type
-   * @returns {LinkedList}
+   * @param type
    */
   listenersFor (type) {
     if (!(type in this.listeners)) {
@@ -63,8 +51,8 @@ class EventTargetService {
    * (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
+   * @param event The event, which is at a phase and has a current target
+   * @returns The errors which the listeners threw
    */
   runEvents (event) {
     const errors = []
@@ -97,8 +85,8 @@ class EventTargetService {
 
   /**
    * Take a listener out of the registered listeners, so that it does not run again.
-   * @param {string} type
-   * @param {PseudoEventListener} listener
+   * @param type
+   * @param listener
    */
   removeListener (type, listener) {
     listener.removed = true
@@ -108,8 +96,8 @@ class EventTargetService {
 
   /**
    * Register the function to run when nothing else has prevented the default for this type of event.
-   * @param {string} type
-   * @param {Function} callback
+   * @param type
+   * @param callback
    */
   setDefaultEvent (type, callback) {
     this.listenersFor(type)
@@ -119,9 +107,9 @@ class EventTargetService {
   /**
    * 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
+   * @param type The type of event to listen for
+   * @param callback The function to call (or an object with a handleEvent function)
+   * @param useCapture 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 = {
@@ -155,9 +143,9 @@ class EventTargetService {
 
   /**
    * 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
+   * @param type The type of event
+   * @param callback The handler which was added
+   * @param options Whether the listener was a capture listener (true), or an object with capture
    */
   removeEventListener (type, callback, options = false) {
     if (!(type in this.listeners)) {
@@ -173,8 +161,8 @@ class EventTargetService {
    * 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
+   * @param event The event to dispatch
+   * @returns 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)
    */

package/dist/services/FocusEventService.d.ts

@@ -1,31 +1,23 @@
 /**
- * @file Substitute for the DOM FocusEvent Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM FocusEvent Class.
  */
 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 & {
+    /** The other target involved (the one losing or gaining the focus) (default null) */
     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
+     * @param typeArg The type of the event
+     * @param init The options for the event
      */
     constructor(typeArg?: string, init?: FocusEventInit);
     get relatedTarget(): PseudoEventTarget | null;

package/dist/services/FocusEventService.js

@@ -5,23 +5,16 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.FocusEventService = void 0
 /**
- * @file Substitute for the DOM FocusEvent Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM FocusEvent Class.
  */
 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
+   * @param typeArg The type of the event
+   * @param init The options for the event
    */
   constructor (typeArg = '', init = {}) {
     super(typeArg, init)

package/dist/services/HTMLCollectionService.d.ts

@@ -1,53 +1,43 @@
 /**
- * @file Substitute for the DOM HTMLCollection Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM HTMLCollection Class.
  */
 import { NodeService } from './NodeService';
 import { PseudoHTMLCollection } from '../interfaces/PseudoHTMLCollection';
 /**
  * Simulate the behaviour of the HTMLCollection Class when there is no DOM available: a live view of some of a node's
  * element descendants, recomputed each time it is used rather than kept in sync as they change.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
  */
 export declare class HTMLCollectionService implements PseudoHTMLCollection {
     private readonly owner;
     private readonly predicate;
     private readonly deep;
     /**
-     * @param {NodeService} owner The node this is a live view of a part of
-     * @param {function(*): boolean} [predicate] Only elements which pass this are included (every element by default)
-     * @param {boolean} [deep=false] Include every matching descendant (true, like getElementsByTagName), not just the
+     * @param owner The node this is a live view of a part of
+     * @param predicate Only elements which pass this are included (every element by default)
+     * @param deep Include every matching descendant (true, like getElementsByTagName), not just the
      * direct element children (false, like Element.children)
-     * @constructor
      */
     constructor(owner: NodeService, predicate?: (element: any) => boolean, deep?: boolean);
     /**
      * The current elements the collection holds, in tree order.
-     * @returns {Array<PseudoNode>}
      */
     private elements;
     /**
      * How many elements are in the collection right now.
-     * @returns {number}
      */
     get length(): number;
     /**
      * The element at the given index, or null when there is none.
-     * @param {number} index
-     * @returns {*}
+     * @param index
      */
     item(index: number): any | null;
     /**
      * The element whose id, or (failing that) whose name attribute, is the given value, or null when there is none.
-     * @param {string} name
-     * @returns {*}
+     * @param name
      */
     namedItem(name: string): any | null;
     /**
      * Iterate over the current elements.
-     * @returns {Iterator}
      */
     [Symbol.iterator](): Iterator<any>;
 }

package/dist/services/HTMLCollectionService.js

@@ -8,24 +8,19 @@ Object.defineProperty(exports, '__esModule', {
 })
 exports.HTMLCollectionService = void 0
 /**
- * @file Substitute for the DOM HTMLCollection Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
+ * Substitute for the DOM HTMLCollection Class.
  */
 const NodeService_1 = require('./NodeService')
 /**
  * Simulate the behaviour of the HTMLCollection Class when there is no DOM available: a live view of some of a node's
  * element descendants, recomputed each time it is used rather than kept in sync as they change.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
  */
 class HTMLCollectionService {
   /**
-   * @param {NodeService} owner The node this is a live view of a part of
-   * @param {function(*): boolean} [predicate] Only elements which pass this are included (every element by default)
-   * @param {boolean} [deep=false] Include every matching descendant (true, like getElementsByTagName), not just the
+   * @param owner The node this is a live view of a part of
+   * @param predicate Only elements which pass this are included (every element by default)
+   * @param deep Include every matching descendant (true, like getElementsByTagName), not just the
    * direct element children (false, like Element.children)
-   * @constructor
    */
   constructor (owner, predicate = () => true, deep = false) {
     this.owner = owner
@@ -35,7 +30,6 @@ class HTMLCollectionService {
 
   /**
    * The current elements the collection holds, in tree order.
-   * @returns {Array<PseudoNode>}
    */
   elements () {
     const results = []
@@ -55,7 +49,6 @@ class HTMLCollectionService {
 
   /**
    * How many elements are in the collection right now.
-   * @returns {number}
    */
   get length () {
     return this.elements().length
@@ -63,8 +56,7 @@ class HTMLCollectionService {
 
   /**
    * The element at the given index, or null when there is none.
-   * @param {number} index
-   * @returns {*}
+   * @param index
    */
   item (index) {
     return this.elements()[index] || null
@@ -72,8 +64,7 @@ class HTMLCollectionService {
 
   /**
    * The element whose id, or (failing that) whose name attribute, is the given value, or null when there is none.
-   * @param {string} name
-   * @returns {*}
+   * @param name
    */
   namedItem (name) {
     const elements = this.elements()
@@ -82,7 +73,6 @@ class HTMLCollectionService {
 
   /**
    * Iterate over the current elements.
-   * @returns {Iterator}
    */
   [Symbol.iterator] () {
     return this.elements()[Symbol.iterator]()