pseudo-dom 0.6.0 → 0.8.0

package/dist/classes/PseudoEventListener.d.ts

@@ -1,96 +1,96 @@
-/**
- * @file Substitute for the DOM EventEventListener Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-import { EventService } from '../services/EventService';
-/**
- * Handle events as they are stored and implemented.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @property {string} eventType
- * @property {Object} eventOptions
- * @property {boolean} isDefault
- */
-declare class PseudoEventListener {
-    private eventOptions;
-    private eventType;
-    private handler;
-    private readonly originalCallback;
-    private readonly defaultListener;
-    private isRemoved;
-    /**
-     * @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: string, { capture, once, passive }: {
-        capture?: boolean;
-        once?: boolean;
-        passive?: boolean;
-    }, handleEvent: Function, originalCallback?: Function);
-    /**
-     * The function (or object with handleEvent) which was originally given when registering, used to find this listener again for removal.
-     */
-    get callback(): Function;
-    /** Whether this listener listens in the capture phase (and at the target) rather than in the bubble phase. */
-    get capture(): boolean;
-    get isDefault(): boolean;
-    get once(): boolean;
-    /** Whether the listener promises not to prevent the default (preventDefault does nothing while it runs). */
-    get passive(): boolean;
-    /** Whether this listener has been removed, a removed listener does not run even if the event already started. */
-    get removed(): boolean;
-    set removed(removed: boolean);
-    /**
-     * @method
-     * @name PseudoEventListener#handleEvent
-     * @param {PseudoEvent} event
-     * @returns {*}
-     */
-    handleEvent(event: EventService): any;
-    /**
-     * A capture listener runs while the event travels down to the target.
-     * @method
-     * @name PseudoEventListener#doCapturePhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
-     */
-    doCapturePhase(event: EventService): boolean;
-    /**
-     * Every listener of the target itself runs, capture listeners first.
-     * @method
-     * @name PseudoEventListener#doTargetPhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
-     */
-    doTargetPhase(event: EventService): boolean;
-    /**
-     * 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}
-     */
-    doBubblePhase(event: EventService): boolean;
-    /**
-     * @method
-     * @name PseudoEventListener#skipPhase
-     * @param {PseudoEvent} event
-     * @returns {boolean}
-     */
-    skipPhase(event: EventService): boolean;
-    /**
-     * 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}
-     */
-    rejectEvent(event: EventService): boolean;
-}
-export default PseudoEventListener;
+/**
+ * @file Substitute for the DOM EventEventListener Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { EventService } from '../services/EventService';
+/**
+ * Handle events as they are stored and implemented.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @property {string} eventType
+ * @property {Object} eventOptions
+ * @property {boolean} isDefault
+ */
+declare class PseudoEventListener {
+    private eventOptions;
+    private eventType;
+    private handler;
+    private readonly originalCallback;
+    private readonly defaultListener;
+    private isRemoved;
+    /**
+     * @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: string, { capture, once, passive }: {
+        capture?: boolean;
+        once?: boolean;
+        passive?: boolean;
+    }, handleEvent: Function, originalCallback?: Function);
+    /**
+     * The function (or object with handleEvent) which was originally given when registering, used to find this listener again for removal.
+     */
+    get callback(): Function;
+    /** Whether this listener listens in the capture phase (and at the target) rather than in the bubble phase. */
+    get capture(): boolean;
+    get isDefault(): boolean;
+    get once(): boolean;
+    /** Whether the listener promises not to prevent the default (preventDefault does nothing while it runs). */
+    get passive(): boolean;
+    /** Whether this listener has been removed, a removed listener does not run even if the event already started. */
+    get removed(): boolean;
+    set removed(removed: boolean);
+    /**
+     * @method
+     * @name PseudoEventListener#handleEvent
+     * @param {PseudoEvent} event
+     * @returns {*}
+     */
+    handleEvent(event: EventService): any;
+    /**
+     * A capture listener runs while the event travels down to the target.
+     * @method
+     * @name PseudoEventListener#doCapturePhase
+     * @param {PseudoEvent} event
+     * @returns {boolean}
+     */
+    doCapturePhase(event: EventService): boolean;
+    /**
+     * Every listener of the target itself runs, capture listeners first.
+     * @method
+     * @name PseudoEventListener#doTargetPhase
+     * @param {PseudoEvent} event
+     * @returns {boolean}
+     */
+    doTargetPhase(event: EventService): boolean;
+    /**
+     * 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}
+     */
+    doBubblePhase(event: EventService): boolean;
+    /**
+     * @method
+     * @name PseudoEventListener#skipPhase
+     * @param {PseudoEvent} event
+     * @returns {boolean}
+     */
+    skipPhase(event: EventService): boolean;
+    /**
+     * 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}
+     */
+    rejectEvent(event: EventService): boolean;
+}
+export default PseudoEventListener;

package/dist/classes/PseudoEventListener.js

@@ -1,151 +1,151 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-/**
- * @file Substitute for the DOM EventEventListener Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-const EventService_1 = require('../services/EventService')
-/**
- * Handle events as they are stored and implemented.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @property {string} eventType
- * @property {Object} eventOptions
- * @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,
-    passive = false
-  } = {}, handleEvent, originalCallback = handleEvent) {
-    this.eventOptions = {
-      capture: false,
-      once: false,
-      passive: false
-    }
-    this.eventType = ''
-    this.defaultListener = false
-    this.isRemoved = false
-    this.eventOptions = {
-      capture,
-      once,
-      passive
-    }
-    this.eventType = eventType
-    this.handler = handleEvent
-    this.originalCallback = originalCallback
-  }
-
-  /**
-   * The function (or object with handleEvent) which was originally given when registering, used to find this listener again for removal.
-   */
-  get callback () {
-    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
-  }
-
-  get once () {
-    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
-   * @param {PseudoEvent} event
-   * @returns {*}
-   */
-  handleEvent (event) {
-    return this.handler(event)
-  }
-
-  /**
-   * A capture listener runs while the event travels down to the target.
-   * @method
-   * @name PseudoEventListener#doCapturePhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
-   */
-  doCapturePhase (event) {
-    return event.eventPhase === EventService_1.EventService.CAPTURING_PHASE && this.eventOptions.capture
-  }
-
-  /**
-   * Every listener of the target itself runs, capture listeners first.
-   * @method
-   * @name PseudoEventListener#doTargetPhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
-   */
-  doTargetPhase (event) {
-    return event.eventPhase === EventService_1.EventService.AT_TARGET
-  }
-
-  /**
-   * 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}
-   */
-  doBubblePhase (event) {
-    return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && !this.eventOptions.capture
-  }
-
-  /**
-   * @method
-   * @name PseudoEventListener#skipPhase
-   * @param {PseudoEvent} event
-   * @returns {boolean}
-   */
-  skipPhase (event) {
-    return !this.doCapturePhase(event) && !this.doTargetPhase(event) && !this.doBubblePhase(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}
-   */
-  rejectEvent (event) {
-    return this.isRemoved || this.skipPhase(event)
-  }
-}
-exports.default = PseudoEventListener
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+/**
+ * @file Substitute for the DOM EventEventListener Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const EventService_1 = require('../services/EventService')
+/**
+ * Handle events as they are stored and implemented.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @property {string} eventType
+ * @property {Object} eventOptions
+ * @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,
+    passive = false
+  } = {}, handleEvent, originalCallback = handleEvent) {
+    this.eventOptions = {
+      capture: false,
+      once: false,
+      passive: false
+    }
+    this.eventType = ''
+    this.defaultListener = false
+    this.isRemoved = false
+    this.eventOptions = {
+      capture,
+      once,
+      passive
+    }
+    this.eventType = eventType
+    this.handler = handleEvent
+    this.originalCallback = originalCallback
+  }
+
+  /**
+   * The function (or object with handleEvent) which was originally given when registering, used to find this listener again for removal.
+   */
+  get callback () {
+    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
+  }
+
+  get once () {
+    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
+   * @param {PseudoEvent} event
+   * @returns {*}
+   */
+  handleEvent (event) {
+    return this.handler(event)
+  }
+
+  /**
+   * A capture listener runs while the event travels down to the target.
+   * @method
+   * @name PseudoEventListener#doCapturePhase
+   * @param {PseudoEvent} event
+   * @returns {boolean}
+   */
+  doCapturePhase (event) {
+    return event.eventPhase === EventService_1.EventService.CAPTURING_PHASE && this.eventOptions.capture
+  }
+
+  /**
+   * Every listener of the target itself runs, capture listeners first.
+   * @method
+   * @name PseudoEventListener#doTargetPhase
+   * @param {PseudoEvent} event
+   * @returns {boolean}
+   */
+  doTargetPhase (event) {
+    return event.eventPhase === EventService_1.EventService.AT_TARGET
+  }
+
+  /**
+   * 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}
+   */
+  doBubblePhase (event) {
+    return event.eventPhase === EventService_1.EventService.BUBBLING_PHASE && !this.eventOptions.capture
+  }
+
+  /**
+   * @method
+   * @name PseudoEventListener#skipPhase
+   * @param {PseudoEvent} event
+   * @returns {boolean}
+   */
+  skipPhase (event) {
+    return !this.doCapturePhase(event) && !this.doTargetPhase(event) && !this.doBubblePhase(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}
+   */
+  rejectEvent (event) {
+    return this.isRemoved || this.skipPhase(event)
+  }
+}
+exports.default = PseudoEventListener

package/dist/classes/PseudoHTMLDocument.d.ts

@@ -3,65 +3,39 @@
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @version 1.0.0
  */
-/**
- *
- * @type {PseudoHTMLElement}
- */
 import { HTMLElementService as PseudoHTMLElement } from '../services/HTMLElementService';
-import { TextService, CommentService } from '../services/NodeService';
-import { DocumentFragmentService } from '../services/DocumentFragmentService';
-import { PseudoNode } from '../interfaces/PseudoNode';
+import { DocumentService } from '../services/DocumentService';
+import { NodeService } from '../services/NodeService';
 /**
- * Simulate the behaviour of the HTMLDocument Class when there is no DOM available.
+ * Simulate the behaviour of the HTMLDocument Class when there is no DOM available. Like the real HTMLDocument, this
+ * only adds the html/head/body structure on top of what Document already gives (createElement, createTextNode,
+ * createComment, createDocumentFragment, getElementById, textContent always null).
  * @author Joshua Heagle <joshuaheagle@gmail.com>
  * @class
- * @augments PseudoHTMLElement
+ * @augments DocumentService
  * @property {PseudoHTMLElement} head - A reference to the Head child element
  * @property {PseudoHTMLElement} body - A reference to the Body child element
- * @property {function} createElement - Generate a new PseudoHTMLElement (which is not in the document until it is appended)
  */
-declare class PseudoHTMLDocument extends PseudoHTMLElement {
-    private head;
-    private body;
+declare class PseudoHTMLDocument extends DocumentService {
+    head: PseudoHTMLElement | null;
+    body: PseudoHTMLElement | null;
     /**
      * The root HTML element is acts as the parent to all HTML elements in the document.
      * @constructor
      */
     constructor();
-    get nodeName(): string;
-    get nodeType(): number;
-    get textContent(): string | null;
-    set textContent(text: string | null);
-    /**
-     * Make an element of the given type which belongs to this document but is not added anywhere until it is appended.
-     * @param {string} tagName - Tag Name is a string representing the type of Dom element this represents
-     * @returns {PseudoHTMLElement}
-     */
-    createElement(tagName?: string): PseudoHTMLElement;
-    /**
-     * Make a text node which belongs to this document.
-     * @param {string} [data=''] The text
-     * @returns {TextService}
-     */
-    createTextNode(data?: string): TextService;
-    /**
-     * Make a comment which belongs to this document.
-     * @param {string} [data=''] The comment
-     * @returns {CommentService}
-     */
-    createComment(data?: string): CommentService;
     /**
-     * Make an empty document fragment which belongs to this document, a container for nodes which can be built up and
-     * then inserted in one go.
-     * @returns {DocumentFragmentService}
+     * A copy of this document with none of its html/head/body (cloneNode, from the inherited cloneShallow hook, fills
+     * them back in, deep copies own document's, empty otherwise - see cloneNode).
+     * @returns {PseudoHTMLDocument}
      */
-    createDocumentFragment(): DocumentFragmentService;
+    protected cloneShallow(): NodeService;
     /**
-     * Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in the
-     * document (a shallow one is an empty document).
+     * Make a copy of this document. The copy has no parent or listeners, and a deep copy has copies of everything in
+     * the document (a shallow one is an empty document).
      * @param {boolean} [deep=false] Copy everything in the document as well
-     * @returns {PseudoNode}
+     * @returns {PseudoHTMLDocument}
      */
-    cloneNode(deep?: boolean): PseudoNode;
+    cloneNode(deep?: boolean): PseudoHTMLDocument;
 }
 export default PseudoHTMLDocument;