pseudo-dom 0.6.0 → 0.8.0

package/dist/classes/PseudoHTMLDocument.js

@@ -2,137 +2,67 @@
 
 require('core-js/modules/esnext.iterator.constructor.js')
 require('core-js/modules/esnext.iterator.find.js')
-require('core-js/modules/esnext.iterator.for-each.js')
 Object.defineProperty(exports, '__esModule', {
   value: true
 })
+const DocumentService_1 = require('../services/DocumentService')
 /**
- * @file Substitute for the DOM HTMLDocument Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-/**
- *
- * @type {PseudoHTMLElement}
- */
-const HTMLElementService_1 = require('../services/HTMLElementService')
-const NodeService_1 = require('../services/NodeService')
-const DocumentFragmentService_1 = require('../services/DocumentFragmentService')
-/**
- * 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)
  */
-class PseudoHTMLDocument extends HTMLElementService_1.HTMLElementService {
+class PseudoHTMLDocument extends DocumentService_1.DocumentService {
   /**
    * The root HTML element is acts as the parent to all HTML elements in the document.
    * @constructor
    */
   constructor () {
     super()
-    const html = new HTMLElementService_1.HTMLElementService({
-      tagName: 'html'
-    })
+    const html = this.createElement('html')
     this.appendChild(html)
     /**
      * Create document head element
      * @type {PseudoHTMLElement}
      */
-    this.head = new HTMLElementService_1.HTMLElementService({
-      tagName: 'head'
-    })
+    this.head = this.createElement('head')
     html.appendChild(this.head)
     /**
      * Create document body element
      * @type {PseudoHTMLElement}
      */
-    this.body = new HTMLElementService_1.HTMLElementService({
-      tagName: 'body'
-    })
+    this.body = this.createElement('body')
     html.appendChild(this.body)
   }
 
-  get nodeName () {
-    return '#document'
-  }
-
-  get nodeType () {
-    return NodeService_1.NodeService.DOCUMENT_NODE
-  }
-
-  // A document has no text of its own, and setting it does nothing
-  get textContent () {
-    return null
-  }
-
-  set textContent (text) {}
-  /**
-   * 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 = 'div') {
-    // Like the DOM, the new element is not added anywhere: it has no parent until it is appended
-    const element = new HTMLElementService_1.HTMLElementService({
-      tagName
-    })
-    element.ownerDocumentStore = this
-    return element
-  }
-
-  /**
-   * Make a text node which belongs to this document.
-   * @param {string} [data=''] The text
-   * @returns {TextService}
-   */
-  createTextNode (data = '') {
-    const text = new NodeService_1.TextService(data)
-    text.ownerDocumentStore = this
-    return text
-  }
-
   /**
-   * Make a comment which belongs to this document.
-   * @param {string} [data=''] The comment
-   * @returns {CommentService}
+   * 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}
    */
-  createComment (data = '') {
-    const comment = new NodeService_1.CommentService(data)
-    comment.ownerDocumentStore = this
-    return comment
-  }
-
-  /**
-   * 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}
-   */
-  createDocumentFragment () {
-    const fragment = new DocumentFragmentService_1.DocumentFragmentService()
-    fragment.ownerDocumentStore = this
-    return fragment
+  cloneShallow () {
+    const copy = new this.constructor()
+    while (copy.firstChild) {
+      copy.removeChild(copy.firstChild)
+    }
+    copy.head = null
+    copy.body = null
+    return copy
   }
 
   /**
-   * 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 = false) {
-    const copy = new PseudoHTMLDocument()
-    // The new document starts out with its own html, head and body, a copy has only what was copied from this one
-    while (copy.firstChild) {
-      copy.removeChild(copy.firstChild)
-    }
-    copy.head = null
-    copy.body = null
+    const copy = super.cloneNode(deep)
     if (deep) {
-      Array.from(this.childNodes).forEach(child => copy.appendChild(child.cloneNode(true)))
       const html = Array.from(copy.childNodes).find(child => child.tagName === 'html')
       const inHtml = tagName => html ? Array.from(html.childNodes).find(child => child.tagName === tagName) || null : null
       copy.head = inHtml('head')

package/dist/classes/PseudoHTMLDocument.min.js

@@ -1 +1 @@
-"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),require("core-js/modules/esnext.iterator.for-each.js"),Object.defineProperty(exports,"__esModule",{value:!0});const HTMLElementService_1=require("../services/HTMLElementService"),NodeService_1=require("../services/NodeService"),DocumentFragmentService_1=require("../services/DocumentFragmentService");class PseudoHTMLDocument extends HTMLElementService_1.HTMLElementService{constructor(){super();const e=new HTMLElementService_1.HTMLElementService({tagName:"html"});this.appendChild(e),this.head=new HTMLElementService_1.HTMLElementService({tagName:"head"}),e.appendChild(this.head),this.body=new HTMLElementService_1.HTMLElementService({tagName:"body"}),e.appendChild(this.body)}get nodeName(){return"#document"}get nodeType(){return NodeService_1.NodeService.DOCUMENT_NODE}get textContent(){return null}set textContent(e){}createElement(e="div"){const t=new HTMLElementService_1.HTMLElementService({tagName:e});return t.ownerDocumentStore=this,t}createTextNode(e=""){const t=new NodeService_1.TextService(e);return t.ownerDocumentStore=this,t}createComment(e=""){const t=new NodeService_1.CommentService(e);return t.ownerDocumentStore=this,t}createDocumentFragment(){const e=new DocumentFragmentService_1.DocumentFragmentService;return e.ownerDocumentStore=this,e}cloneNode(e=!1){const t=new PseudoHTMLDocument;for(;t.firstChild;)t.removeChild(t.firstChild);if(t.head=null,t.body=null,e){Array.from(this.childNodes).forEach(e=>t.appendChild(e.cloneNode(!0)));const e=Array.from(t.childNodes).find(e=>"html"===e.tagName),r=t=>e&&Array.from(e.childNodes).find(e=>e.tagName===t)||null;t.head=r("head"),t.body=r("body")}return t}}exports.default=PseudoHTMLDocument;
+"use strict";require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.find.js"),Object.defineProperty(exports,"__esModule",{value:!0});const DocumentService_1=require("../services/DocumentService");class PseudoHTMLDocument extends DocumentService_1.DocumentService{constructor(){super();const e=this.createElement("html");this.appendChild(e),this.head=this.createElement("head"),e.appendChild(this.head),this.body=this.createElement("body"),e.appendChild(this.body)}cloneShallow(){const e=new this.constructor;for(;e.firstChild;)e.removeChild(e.firstChild);return e.head=null,e.body=null,e}cloneNode(e=!1){const t=super.cloneNode(e);if(e){const e=Array.from(t.childNodes).find(e=>"html"===e.tagName),o=t=>e&&Array.from(e.childNodes).find(e=>e.tagName===t)||null;t.head=o("head"),t.body=o("body")}return t}}exports.default=PseudoHTMLDocument;

package/dist/classes/PseudoNodeList.d.ts

@@ -1,34 +1,34 @@
-/**
- * @file Substitute for the NodeList interface.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-import { LinkedTreeList } from 'collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList';
-/**
- * A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
- * the linkers that hold them.
- * @class
- * @augments LinkedTreeList
- */
-export declare class PseudoNodeList extends LinkedTreeList {
-    /**
-     * Iterate over the nodes in this list.
-     * @returns {Iterator}
-     */
-    [Symbol.iterator](): Iterator<any>;
-    /**
-     * Iterate over [index, node] pairs.
-     * @returns {Iterator}
-     */
-    entries(): Iterator<[number, any]>;
-    /**
-     * Iterate over the indexes.
-     * @returns {Iterator}
-     */
-    keys(): Iterator<number>;
-    /**
-     * Iterate over the nodes.
-     * @returns {Iterator}
-     */
-    values(): Iterator<any>;
-}
+/**
+ * @file Substitute for the NodeList interface.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { LinkedTreeList } from 'collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList';
+/**
+ * A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
+ * the linkers that hold them.
+ * @class
+ * @augments LinkedTreeList
+ */
+export declare class PseudoNodeList extends LinkedTreeList {
+    /**
+     * Iterate over the nodes in this list.
+     * @returns {Iterator}
+     */
+    [Symbol.iterator](): Iterator<any>;
+    /**
+     * Iterate over [index, node] pairs.
+     * @returns {Iterator}
+     */
+    entries(): Iterator<[number, any]>;
+    /**
+     * Iterate over the indexes.
+     * @returns {Iterator}
+     */
+    keys(): Iterator<number>;
+    /**
+     * Iterate over the nodes.
+     * @returns {Iterator}
+     */
+    values(): Iterator<any>;
+}

package/dist/classes/PseudoNodeList.js

@@ -1,71 +1,71 @@
-'use strict'
-
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.map.js')
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.PseudoNodeList = void 0
-/**
- * @file Substitute for the NodeList interface.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-const LinkedTreeList_1 = require('collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList')
-/**
- * A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
- * the linkers that hold them.
- * @class
- * @augments LinkedTreeList
- */
-class PseudoNodeList extends LinkedTreeList_1.LinkedTreeList {
-  /**
-   * Iterate over the nodes in this list.
-   * @returns {Iterator}
-   */
-  [Symbol.iterator] () {
-    // Walk the nodes of this list only (the linkers of a child list have no children of their own)
-    let current = this.first
-    return {
-      next: () => {
-        if (current === null) {
-          return {
-            done: true,
-            value: undefined
-          }
-        }
-        const result = {
-          done: false,
-          value: current.data
-        }
-        current = current.next
-        return result
-      }
-    }
-  }
-
-  /**
-   * Iterate over [index, node] pairs.
-   * @returns {Iterator}
-   */
-  entries () {
-    return Array.from(this).map((node, index) => [index, node])[Symbol.iterator]()
-  }
-
-  /**
-   * Iterate over the indexes.
-   * @returns {Iterator}
-   */
-  keys () {
-    return Array.from(this).map((node, index) => index)[Symbol.iterator]()
-  }
-
-  /**
-   * Iterate over the nodes.
-   * @returns {Iterator}
-   */
-  values () {
-    return Array.from(this)[Symbol.iterator]()
-  }
-}
-exports.PseudoNodeList = PseudoNodeList
+'use strict'
+
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.map.js')
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.PseudoNodeList = void 0
+/**
+ * @file Substitute for the NodeList interface.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const LinkedTreeList_1 = require('collect-your-stuff/dist/collections/linked-tree-list/LinkedTreeList')
+/**
+ * A NodeList, like the DOM one, iterates over the nodes themselves (the data stored in each TreeLinker), rather than
+ * the linkers that hold them.
+ * @class
+ * @augments LinkedTreeList
+ */
+class PseudoNodeList extends LinkedTreeList_1.LinkedTreeList {
+  /**
+   * Iterate over the nodes in this list.
+   * @returns {Iterator}
+   */
+  [Symbol.iterator] () {
+    // Walk the nodes of this list only (the linkers of a child list have no children of their own)
+    let current = this.first
+    return {
+      next: () => {
+        if (current === null) {
+          return {
+            done: true,
+            value: undefined
+          }
+        }
+        const result = {
+          done: false,
+          value: current.data
+        }
+        current = current.next
+        return result
+      }
+    }
+  }
+
+  /**
+   * Iterate over [index, node] pairs.
+   * @returns {Iterator}
+   */
+  entries () {
+    return Array.from(this).map((node, index) => [index, node])[Symbol.iterator]()
+  }
+
+  /**
+   * Iterate over the indexes.
+   * @returns {Iterator}
+   */
+  keys () {
+    return Array.from(this).map((node, index) => index)[Symbol.iterator]()
+  }
+
+  /**
+   * Iterate over the nodes.
+   * @returns {Iterator}
+   */
+  values () {
+    return Array.from(this)[Symbol.iterator]()
+  }
+}
+exports.PseudoNodeList = PseudoNodeList

package/dist/factories/createEvent.d.ts

@@ -1,28 +1,28 @@
-import { EventService } from '../services/EventService';
-/**
- * How the event is being created.
- * @typedef {Object} CreateEventOptions
- * @property {boolean} [browser=false] The browser is creating the event (for a user action, or for something like
- * element.click()), so the standard options for the type of event apply where the init does not give its own
- * @property {boolean} [trusted=false] The event comes from a real user action rather than from a script (isTrusted)
- */
-export type CreateEventOptions = {
-    browser?: boolean;
-    trusted?: boolean;
-};
-/**
- * Create an event of the kind which suits its type (a click is a MouseEvent, a keydown a KeyboardEvent, ...).
- * By default this is like using the constructor of the event in a script: nothing bubbles or can be cancelled unless
- * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
- * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
- * real user action (isTrusted).
- * @function createEvent
- * @param {string} type The type of the event, such as click
- * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
- * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
- * @returns {EventService}
- */
-export declare const createEvent: (type: string, init?: {
-    [option: string]: any;
-}, { browser, trusted }?: CreateEventOptions) => EventService;
-export default createEvent;
+import { EventService } from '../services/EventService';
+/**
+ * How the event is being created.
+ * @typedef {Object} CreateEventOptions
+ * @property {boolean} [browser=false] The browser is creating the event (for a user action, or for something like
+ * element.click()), so the standard options for the type of event apply where the init does not give its own
+ * @property {boolean} [trusted=false] The event comes from a real user action rather than from a script (isTrusted)
+ */
+export type CreateEventOptions = {
+    browser?: boolean;
+    trusted?: boolean;
+};
+/**
+ * Create an event of the kind which suits its type (a click is a MouseEvent, a keydown a KeyboardEvent, ...).
+ * By default this is like using the constructor of the event in a script: nothing bubbles or can be cancelled unless
+ * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
+ * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
+ * real user action (isTrusted).
+ * @function createEvent
+ * @param {string} type The type of the event, such as click
+ * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
+ * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
+ * @returns {EventService}
+ */
+export declare const createEvent: (type: string, init?: {
+    [option: string]: any;
+}, { browser, trusted }?: CreateEventOptions) => EventService;
+export default createEvent;

package/dist/factories/createEvent.js

@@ -1,56 +1,56 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.createEvent = void 0
-const EventService_1 = require('../services/EventService')
-const UIEventService_1 = require('../services/UIEventService')
-const MouseEventService_1 = require('../services/MouseEventService')
-const PointerEventService_1 = require('../services/PointerEventService')
-const KeyboardEventService_1 = require('../services/KeyboardEventService')
-const FocusEventService_1 = require('../services/FocusEventService')
-const InputEventService_1 = require('../services/InputEventService')
-const CustomEventService_1 = require('../services/CustomEventService')
-const eventDefaults_1 = require('./eventDefaults')
-const eventClasses = {
-  Event: EventService_1.EventService,
-  UIEvent: UIEventService_1.UIEventService,
-  MouseEvent: MouseEventService_1.MouseEventService,
-  PointerEvent: PointerEventService_1.PointerEventService,
-  KeyboardEvent: KeyboardEventService_1.KeyboardEventService,
-  FocusEvent: FocusEventService_1.FocusEventService,
-  InputEvent: InputEventService_1.InputEventService,
-  CustomEvent: CustomEventService_1.CustomEventService
-}
-/**
- * Create an event of the kind which suits its type (a click is a MouseEvent, a keydown a KeyboardEvent, ...).
- * By default this is like using the constructor of the event in a script: nothing bubbles or can be cancelled unless
- * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
- * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
- * real user action (isTrusted).
- * @function createEvent
- * @param {string} type The type of the event, such as click
- * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
- * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
- * @returns {EventService}
- */
-const createEvent = (type, init = {}, {
-  browser = false,
-  trusted = false
-} = {}) => {
-  const definition = eventDefaults_1.eventDefaults[type]
-  const options = browser && definition
-    ? Object.assign({
-      bubbles: definition.bubbles,
-      cancelable: definition.cancelable,
-      composed: definition.composed
-    }, init)
-    : init
-  const EventClass = eventClasses[definition ? definition.interface : 'Event']
-  const event = new EventClass(type, options)
-  event.inner.trusted = trusted
-  return event
-}
-exports.createEvent = createEvent
-exports.default = exports.createEvent
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.createEvent = void 0
+const EventService_1 = require('../services/EventService')
+const UIEventService_1 = require('../services/UIEventService')
+const MouseEventService_1 = require('../services/MouseEventService')
+const PointerEventService_1 = require('../services/PointerEventService')
+const KeyboardEventService_1 = require('../services/KeyboardEventService')
+const FocusEventService_1 = require('../services/FocusEventService')
+const InputEventService_1 = require('../services/InputEventService')
+const CustomEventService_1 = require('../services/CustomEventService')
+const eventDefaults_1 = require('./eventDefaults')
+const eventClasses = {
+  Event: EventService_1.EventService,
+  UIEvent: UIEventService_1.UIEventService,
+  MouseEvent: MouseEventService_1.MouseEventService,
+  PointerEvent: PointerEventService_1.PointerEventService,
+  KeyboardEvent: KeyboardEventService_1.KeyboardEventService,
+  FocusEvent: FocusEventService_1.FocusEventService,
+  InputEvent: InputEventService_1.InputEventService,
+  CustomEvent: CustomEventService_1.CustomEventService
+}
+/**
+ * Create an event of the kind which suits its type (a click is a MouseEvent, a keydown a KeyboardEvent, ...).
+ * By default this is like using the constructor of the event in a script: nothing bubbles or can be cancelled unless
+ * the init says so, and the event is not trusted. With browser: true the event is created the way the browser creates
+ * it, using the standard options for its type (see eventDefaults), and trusted: true makes it look like it came from a
+ * real user action (isTrusted).
+ * @function createEvent
+ * @param {string} type The type of the event, such as click
+ * @param {Object} [init={}] The options for the event (bubbles, cancelable, composed and those of its kind of event)
+ * @param {CreateEventOptions} [options={}] Whether the browser is creating the event, and whether it is trusted
+ * @returns {EventService}
+ */
+const createEvent = (type, init = {}, {
+  browser = false,
+  trusted = false
+} = {}) => {
+  const definition = eventDefaults_1.eventDefaults[type]
+  const options = browser && definition
+    ? Object.assign({
+      bubbles: definition.bubbles,
+      cancelable: definition.cancelable,
+      composed: definition.composed
+    }, init)
+    : init
+  const EventClass = eventClasses[definition ? definition.interface : 'Event']
+  const event = new EventClass(type, options)
+  event.inner.trusted = trusted
+  return event
+}
+exports.createEvent = createEvent
+exports.default = exports.createEvent

package/dist/factories/cssSelectAdapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Maps pseudo-dom's own Node / Element API onto the Adapter interface css-select needs to query a tree which is not
+ * domutils' own (css-select's own Adapter<Node, ElementNode> type). Every method here is one pseudo-dom already has
+ * under a different name; nothing here reimplements DOM behaviour.
+ * @memberOf module:factories
+ * @type {Object}
+ */
+export declare const cssSelectAdapter: {
+    isTag: (node: any) => boolean;
+    existsOne: (test: (elem: any) => boolean, elems: Array<any>) => boolean;
+    getAttributeValue: (elem: any, name: string) => string | undefined;
+    getChildren: (node: any) => Array<any>;
+    getName: (elem: any) => string;
+    getParent: (node: any) => any | null;
+    getSiblings: (node: any) => Array<any>;
+    prevElementSibling: (node: any) => any | null;
+    getText: (node: any) => string;
+    hasAttrib: (elem: any, name: string) => boolean;
+    removeSubsets: (nodes: Array<any>) => Array<any>;
+    findAll: (test: (elem: any) => boolean, nodes: Array<any>) => Array<any>;
+    findOne: (test: (elem: any) => boolean, nodes: Array<any>) => any | null;
+};
+export default cssSelectAdapter;