pseudo-dom 0.1.0 → 0.3.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/NodeService.d.ts

@@ -1,5 +1,6 @@
 import { PseudoNodeList } from '../classes/PseudoNodeList';
 import { LinkedTreeList } from 'collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList';
+import { TreeLinker } from 'collect-your-stuff/dist/collections/linked-tree-list/TreeLinker';
 import { PseudoNode } from '../interfaces/PseudoNode';
 import EventTargetService from './EventTargetService';
 import { PseudoElement } from '../interfaces/PseudoElement';
@@ -33,8 +34,8 @@ export declare class NodeService extends EventTargetService implements PseudoNod
     protected nodeNameValue: string;
     private nodeValueStore;
     private textContentStore;
-    private next;
-    private prev;
+    /** The linker which holds this node in the children list of its parent, from which its siblings are found (null while it has no parent). */
+    protected listLinker: TreeLinker | null;
     /**
      *
      * @constructor
@@ -57,11 +58,17 @@ export declare class NodeService extends EventTargetService implements PseudoNod
     get textContent(): string | null;
     set textContent(text: string | null);
     /**
-     *
-     * @param {PseudoNode} childNode
-     * @returns {PseudoNode}
+     * Add a node as the last child of this node (a node which is already in a tree is moved).
+     * @param {PseudoNode} childNode The node to add
+     * @returns {PseudoNode} The added node
      */
     appendChild(childNode: PseudoNode): PseudoNode;
+    /**
+     * Called each time a node has been inserted as a child of this node, so that nodes which need to react to children
+     * (for example elements applying default events) can do so.
+     * @param {NodeService} child The node which was inserted
+     */
+    protected childInserted(child: NodeService): void;
     /**
      * Not implemented yet.
      * @throws {Error}
@@ -73,19 +80,24 @@ export declare class NodeService extends EventTargetService implements PseudoNod
      */
     compareDocumentPosition(otherNode: PseudoNode): number;
     /**
-     * Not implemented yet.
-     * @throws {Error}
+     * Check whether a node is this node or one of its descendants.
+     * @param {PseudoNode|null} otherNode The node to look for
+     * @returns {boolean}
      */
-    contains(otherNode: PseudoNode): boolean;
+    contains(otherNode: PseudoNode | null): boolean;
     getRootNode(options?: {
         composed: boolean;
     }): PseudoNode;
     hasChildNodes(): boolean;
     /**
-     * Not implemented yet.
-     * @throws {Error}
+     * Insert a node as a child of this node, before the given child (or at the end when there is none). A node which is
+     * already in a tree is moved, and the children of a document fragment are moved in order.
+     * @param {PseudoNode} newNode The node to insert
+     * @param {PseudoNode|null} [referenceNode=null] The child of this node to insert before, or null to insert at the end
+     * @returns {PseudoNode} The inserted node
+     * @throws {Error} When the reference node is not a child of this node, or the new node is this node or contains it
      */
-    insertBefore(newNode: PseudoNode, referenceNode: PseudoNode | null): PseudoNode | PseudoDocumentFragment;
+    insertBefore(newNode: PseudoNode, referenceNode?: PseudoNode | null): PseudoNode | PseudoDocumentFragment;
     isDefaultNamespace(namespaceURI: string | null): boolean;
     /**
      * Not implemented yet.
@@ -97,15 +109,18 @@ export declare class NodeService extends EventTargetService implements PseudoNod
     lookupNamespaceURI(prefix: string): string | null;
     normalize(): void;
     /**
-     * Remove the given child from this node.
-     * @param {PseudoNode} childElement The child node, or its TreeLinker from the children list
-     * @returns {PseudoNode}
+     * Remove a child from this node, it no longer has a parent or siblings afterwards.
+     * @param {PseudoNode} childElement The child node to remove
+     * @returns {PseudoNode} The removed node
      * @throws {Error} When the node is not a child of this node
      */
     removeChild(childElement: PseudoNode): PseudoNode;
     /**
-     * Not implemented yet.
-     * @throws {Error}
+     * Replace a child of this node with another node (which is moved if it is already in a tree).
+     * @param {PseudoNode} newChild The node which takes the place
+     * @param {PseudoNode} oldChild The child of this node to replace
+     * @returns {PseudoNode} The replaced node
+     * @throws {Error} When the old node is not a child of this node
      */
     replaceChild(newChild: PseudoNode, oldChild: PseudoNode): PseudoNode;
 }

package/dist/services/NodeService.js

@@ -1,7 +1,5 @@
 'use strict'
 
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.for-each.js')
 const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
   return mod && mod.__esModule
     ? mod
@@ -19,6 +17,7 @@ exports.NodeService = void 0
  * @version 1.0.0
  */
 const generateNodeList_1 = __importDefault(require('../factories/generateNodeList'))
+const TreeLinker_1 = require('collect-your-stuff/dist/collections/linked-tree-list/TreeLinker')
 const EventTargetService_1 = __importDefault(require('./EventTargetService'))
 /**
  * Simulate the behaviour of the Node Class when there is no DOM available.
@@ -41,8 +40,7 @@ class NodeService extends EventTargetService_1.default {
     this.nodeNameValue = ''
     this.children = (0, generateNodeList_1.default)()
     this.parent = null
-    this.next = null
-    this.prev = null
+    this.listLinker = null
   }
 
   get baseURI () {
@@ -66,7 +64,7 @@ class NodeService extends EventTargetService_1.default {
   }
 
   get nextSibling () {
-    return this.isConnected ? this.next : null
+    return this.listLinker && this.listLinker.next ? this.listLinker.next.data : null
   }
 
   get nodeName () {
@@ -98,7 +96,7 @@ class NodeService extends EventTargetService_1.default {
   }
 
   get previousSibling () {
-    return this.isConnected ? this.prev : null
+    return this.listLinker && this.listLinker.prev ? this.listLinker.prev.data : null
   }
 
   get textContent () {
@@ -110,15 +108,20 @@ class NodeService extends EventTargetService_1.default {
   }
 
   /**
-   *
-   * @param {PseudoNode} childNode
-   * @returns {PseudoNode}
+   * Add a node as the last child of this node (a node which is already in a tree is moved).
+   * @param {PseudoNode} childNode The node to add
+   * @returns {PseudoNode} The added node
    */
   appendChild (childNode) {
-    this.children.append(childNode)
-    return childNode
+    return this.insertBefore(childNode, null)
   }
 
+  /**
+   * Called each time a node has been inserted as a child of this node, so that nodes which need to react to children
+   * (for example elements applying default events) can do so.
+   * @param {NodeService} child The node which was inserted
+   */
+  childInserted (child) {}
   /**
    * Not implemented yet.
    * @throws {Error}
@@ -136,11 +139,19 @@ class NodeService extends EventTargetService_1.default {
   }
 
   /**
-   * Not implemented yet.
-   * @throws {Error}
+   * Check whether a node is this node or one of its descendants.
+   * @param {PseudoNode|null} otherNode The node to look for
+   * @returns {boolean}
    */
   contains (otherNode) {
-    throw new Error('NodeService.contains() is not implemented yet.')
+    let current = otherNode
+    while (current) {
+      if (current === this) {
+        return true
+      }
+      current = current.parentNode
+    }
+    return false
   }
 
   getRootNode (options = {
@@ -154,11 +165,44 @@ class NodeService extends EventTargetService_1.default {
   }
 
   /**
-   * Not implemented yet.
-   * @throws {Error}
+   * Insert a node as a child of this node, before the given child (or at the end when there is none). A node which is
+   * already in a tree is moved, and the children of a document fragment are moved in order.
+   * @param {PseudoNode} newNode The node to insert
+   * @param {PseudoNode|null} [referenceNode=null] The child of this node to insert before, or null to insert at the end
+   * @returns {PseudoNode} The inserted node
+   * @throws {Error} When the reference node is not a child of this node, or the new node is this node or contains it
    */
-  insertBefore (newNode, referenceNode) {
-    throw new Error('NodeService.insertBefore() is not implemented yet.')
+  insertBefore (newNode, referenceNode = null) {
+    if (referenceNode !== null && referenceNode.parentNode !== this) {
+      throw new Error('The node before which the new node is to be inserted is not a child of this node.')
+    }
+    if (newNode === referenceNode) {
+      // Inserting a node before itself leaves it where it is
+      return newNode
+    }
+    if (typeof newNode.contains === 'function' && newNode.contains(this)) {
+      throw new Error('The new node cannot be inserted into itself or one of its own descendants.')
+    }
+    if (newNode.nodeType === NodeService.DOCUMENT_FRAGMENT_NODE) {
+      // The children of a fragment are inserted (moved) in order, and the fragment is left empty
+      while (newNode.firstChild) {
+        this.insertBefore(newNode.firstChild, referenceNode)
+      }
+      return newNode
+    }
+    if (newNode.parentNode) {
+      // A node can only be in one place, so it is moved from where it was
+      newNode.parentNode.removeChild(newNode)
+    }
+    const linker = new TreeLinker_1.TreeLinker({
+      data: newNode
+    })
+    this.children.insertBefore(referenceNode ? referenceNode.listLinker : null, linker)
+    const inserted = newNode
+    inserted.parent = this
+    inserted.listLinker = linker
+    this.childInserted(inserted)
+    return newNode
   }
 
   isDefaultNamespace (namespaceURI) {
@@ -187,31 +231,44 @@ class NodeService extends EventTargetService_1.default {
 
   normalize () {}
   /**
-   * Remove the given child from this node.
-   * @param {PseudoNode} childElement The child node, or its TreeLinker from the children list
-   * @returns {PseudoNode}
+   * Remove a child from this node, it no longer has a parent or siblings afterwards.
+   * @param {PseudoNode} childElement The child node to remove
+   * @returns {PseudoNode} The removed node
    * @throws {Error} When the node is not a child of this node
    */
   removeChild (childElement) {
-    let found = null
-    this.children.forEach(linker => {
-      if (found === null && (linker === childElement || linker.data === childElement)) {
-        found = linker
-      }
-    })
-    if (found === null) {
+    if (!childElement || childElement.parentNode !== this) {
       throw new Error('The node to be removed is not a child of this node.')
     }
-    this.children.remove(found)
-    return found.data
+    const removed = childElement
+    this.children.remove(removed.listLinker)
+    removed.parent = null
+    removed.listLinker = null
+    return childElement
   }
 
   /**
-   * Not implemented yet.
-   * @throws {Error}
+   * Replace a child of this node with another node (which is moved if it is already in a tree).
+   * @param {PseudoNode} newChild The node which takes the place
+   * @param {PseudoNode} oldChild The child of this node to replace
+   * @returns {PseudoNode} The replaced node
+   * @throws {Error} When the old node is not a child of this node
    */
   replaceChild (newChild, oldChild) {
-    throw new Error('NodeService.replaceChild() is not implemented yet.')
+    if (!oldChild || oldChild.parentNode !== this) {
+      throw new Error('The node to be replaced is not a child of this node.')
+    }
+    if (newChild === oldChild) {
+      return oldChild
+    }
+    // The new node goes where the old one was, which is before the old node's next sibling (unless that is the new node)
+    let reference = oldChild.nextSibling
+    if (reference === newChild) {
+      reference = newChild.nextSibling
+    }
+    this.removeChild(oldChild)
+    this.insertBefore(newChild, reference)
+    return oldChild
   }
 }
 exports.NodeService = NodeService

package/dist/services/NodeService.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.iterator.constructor.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}),exports.NodeService=void 0;const generateNodeList_1=__importDefault(require("../factories/generateNodeList")),EventTargetService_1=__importDefault(require("./EventTargetService"));class NodeService extends EventTargetService_1.default{constructor(){super(),this.nodeValueStore="",this.textContentStore="",this.nodeNameValue="",this.children=(0,generateNodeList_1.default)(),this.parent=null,this.next=null,this.prev=null}get baseURI(){return window.location||"/"}get childNodes(){return this.children}get firstChild(){return this.children.first?this.children.first.data:null}get isConnected(){return!!this.parent}get lastChild(){return this.children.last?this.children.last.data:null}get nextSibling(){return this.isConnected?this.next:null}get nodeName(){return this.nodeNameValue||""}get nodeType(){return NodeService.DEFAULT_NODE}get nodeValue(){return this.nodeValueStore}set nodeValue(e){this.nodeValueStore=e}get ownerDocument(){return null}get parentNode(){return this.parent}get parentElement(){return this.parent&&this.parent.nodeType===NodeService.ELEMENT_NODE?this.parent:null}get previousSibling(){return this.isConnected?this.prev:null}get textContent(){return this.textContentStore}set textContent(e){this.textContentStore=e}appendChild(e){return this.children.append(e),e}cloneNode(e=!1){throw new Error(`NodeService.cloneNode(${e}) is not implemented yet.`)}compareDocumentPosition(e){throw new Error("NodeService.compareDocumentPosition() is not implemented yet.")}contains(e){throw new Error("NodeService.contains() is not implemented yet.")}getRootNode(e={composed:!1}){return this.parent?this.parent.getRootNode(e):this}hasChildNodes(){return this.children.length>0}insertBefore(e,t){throw new Error("NodeService.insertBefore() is not implemented yet.")}isDefaultNamespace(e){return null===e}isEqualNode(e){throw new Error("NodeService.isEqualNode() is not implemented yet.")}isSameNode(e){return this===e}lookupPrefix(e){return null}lookupNamespaceURI(e){return null}normalize(){}removeChild(e){let t=null;if(this.children.forEach(r=>{null!==t||r!==e&&r.data!==e||(t=r)}),null===t)throw new Error("The node to be removed is not a child of this node.");return this.children.remove(t),t.data}replaceChild(e,t){throw new Error("NodeService.replaceChild() is not implemented yet.")}}exports.NodeService=NodeService,NodeService.DEFAULT_NODE=0,NodeService.ELEMENT_NODE=1,NodeService.ATTRIBUTE_NODE=2,NodeService.TEXT_NODE=3,NodeService.CDATA_SECTION_NODE=4,NodeService.ENTITY_REFERENCE_NODE=5,NodeService.ENTITY_NODE=6,NodeService.PROCESSING_INSTRUCTION_NODE=7,NodeService.COMMENT_NODE=8,NodeService.DOCUMENT_NODE=9,NodeService.DOCUMENT_TYPE_NODE=10,NodeService.DOCUMENT_FRAGMENT_NODE=11,NodeService.NOTATION_NODE=12;
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.NodeService=void 0;const generateNodeList_1=__importDefault(require("../factories/generateNodeList")),TreeLinker_1=require("collect-your-stuff/dist/collections/linked-tree-list/TreeLinker"),EventTargetService_1=__importDefault(require("./EventTargetService"));class NodeService extends EventTargetService_1.default{constructor(){super(),this.nodeValueStore="",this.textContentStore="",this.nodeNameValue="",this.children=(0,generateNodeList_1.default)(),this.parent=null,this.listLinker=null}get baseURI(){return window.location||"/"}get childNodes(){return this.children}get firstChild(){return this.children.first?this.children.first.data:null}get isConnected(){return!!this.parent}get lastChild(){return this.children.last?this.children.last.data:null}get nextSibling(){return this.listLinker&&this.listLinker.next?this.listLinker.next.data:null}get nodeName(){return this.nodeNameValue||""}get nodeType(){return NodeService.DEFAULT_NODE}get nodeValue(){return this.nodeValueStore}set nodeValue(e){this.nodeValueStore=e}get ownerDocument(){return null}get parentNode(){return this.parent}get parentElement(){return this.parent&&this.parent.nodeType===NodeService.ELEMENT_NODE?this.parent:null}get previousSibling(){return this.listLinker&&this.listLinker.prev?this.listLinker.prev.data:null}get textContent(){return this.textContentStore}set textContent(e){this.textContentStore=e}appendChild(e){return this.insertBefore(e,null)}childInserted(e){}cloneNode(e=!1){throw new Error(`NodeService.cloneNode(${e}) is not implemented yet.`)}compareDocumentPosition(e){throw new Error("NodeService.compareDocumentPosition() is not implemented yet.")}contains(e){let t=e;for(;t;){if(t===this)return!0;t=t.parentNode}return!1}getRootNode(e={composed:!1}){return this.parent?this.parent.getRootNode(e):this}hasChildNodes(){return this.children.length>0}insertBefore(e,t=null){if(null!==t&&t.parentNode!==this)throw new Error("The node before which the new node is to be inserted is not a child of this node.");if(e===t)return e;if("function"==typeof e.contains&&e.contains(this))throw new Error("The new node cannot be inserted into itself or one of its own descendants.");if(e.nodeType===NodeService.DOCUMENT_FRAGMENT_NODE){for(;e.firstChild;)this.insertBefore(e.firstChild,t);return e}e.parentNode&&e.parentNode.removeChild(e);const r=new TreeLinker_1.TreeLinker({data:e});this.children.insertBefore(t?t.listLinker:null,r);const i=e;return i.parent=this,i.listLinker=r,this.childInserted(i),e}isDefaultNamespace(e){return null===e}isEqualNode(e){throw new Error("NodeService.isEqualNode() is not implemented yet.")}isSameNode(e){return this===e}lookupPrefix(e){return null}lookupNamespaceURI(e){return null}normalize(){}removeChild(e){if(!e||e.parentNode!==this)throw new Error("The node to be removed is not a child of this node.");const t=e;return this.children.remove(t.listLinker),t.parent=null,t.listLinker=null,e}replaceChild(e,t){if(!t||t.parentNode!==this)throw new Error("The node to be replaced is not a child of this node.");if(e===t)return t;let r=t.nextSibling;return r===e&&(r=e.nextSibling),this.removeChild(t),this.insertBefore(e,r),t}}exports.NodeService=NodeService,NodeService.DEFAULT_NODE=0,NodeService.ELEMENT_NODE=1,NodeService.ATTRIBUTE_NODE=2,NodeService.TEXT_NODE=3,NodeService.CDATA_SECTION_NODE=4,NodeService.ENTITY_REFERENCE_NODE=5,NodeService.ENTITY_NODE=6,NodeService.PROCESSING_INSTRUCTION_NODE=7,NodeService.COMMENT_NODE=8,NodeService.DOCUMENT_NODE=9,NodeService.DOCUMENT_TYPE_NODE=10,NodeService.DOCUMENT_FRAGMENT_NODE=11,NodeService.NOTATION_NODE=12;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pseudo-dom",
   "description": "Mock the DOM on the server side for managing state and testing",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
   "author": "Joshua Heagle",
@@ -18,7 +18,7 @@
     "watch:test": "gulp watchTest"
   },
   "dependencies": {
-    "collect-your-stuff": "^1.2.8",
+    "collect-your-stuff": "^2.1.0",
     "core-js": "^3.50.0"
   },
   "devDependencies": {