pseudo-dom 0.3.0 → 0.5.0

package/dist/classes/PseudoHTMLDocument.d.ts

@@ -8,6 +8,9 @@
  * @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';
 /**
  * Simulate the behaviour of the HTMLDocument Class when there is no DOM available.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -25,11 +28,40 @@ declare class PseudoHTMLDocument extends PseudoHTMLElement {
      * @constructor
      */
     constructor();
+    get nodeName(): string;
+    get nodeType(): number;
+    get textContent(): string | null;
+    set textContent(text: string | null);
     /**
-     * Create and return a PseudoHTMLElement, which is not added to the document until it is appended somewhere
+     * 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}
+     */
+    createDocumentFragment(): DocumentFragmentService;
+    /**
+     * 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}
+     */
+    cloneNode(deep?: boolean): PseudoNode;
 }
 export default PseudoHTMLDocument;

package/dist/classes/PseudoHTMLDocument.js

@@ -1,5 +1,8 @@
 '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: true
 })
@@ -13,6 +16,8 @@ Object.defineProperty(exports, '__esModule', {
  * @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.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -51,16 +56,89 @@ class PseudoHTMLDocument extends HTMLElementService_1.HTMLElementService {
     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) {}
   /**
-   * Create and return a PseudoHTMLElement, which is not added to the document until it is appended somewhere
+   * 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
-    return new HTMLElementService_1.HTMLElementService({
+    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}
+   */
+  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
+  }
+
+  /**
+   * 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}
+   */
+  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
+    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')
+      copy.body = inHtml('body')
+    }
+    return copy
   }
 }
 exports.default = PseudoHTMLDocument

package/dist/classes/PseudoHTMLDocument.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const HTMLElementService_1=require("../services/HTMLElementService");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)}createElement(e="div"){return new HTMLElementService_1.HTMLElementService({tagName:e})}}exports.default=PseudoHTMLDocument;
+"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;

package/dist/factories/createEvent.d.ts

@@ -0,0 +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;

package/dist/factories/createEvent.js

@@ -0,0 +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

package/dist/factories/createEvent.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.createEvent=void 0;const EventService_1=require("../services/EventService"),UIEventService_1=require("../services/UIEventService"),MouseEventService_1=require("../services/MouseEventService"),PointerEventService_1=require("../services/PointerEventService"),KeyboardEventService_1=require("../services/KeyboardEventService"),FocusEventService_1=require("../services/FocusEventService"),InputEventService_1=require("../services/InputEventService"),CustomEventService_1=require("../services/CustomEventService"),eventDefaults_1=require("./eventDefaults"),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},createEvent=(e,t={},{browser:v=!1,trusted:r=!1}={})=>{const n=eventDefaults_1.eventDefaults[e],c=v&&n?Object.assign({bubbles:n.bubbles,cancelable:n.cancelable,composed:n.composed},t):t,i=new(0,eventClasses[n?n.interface:"Event"])(e,c);return i.inner.trusted=r,i};exports.createEvent=createEvent,exports.default=exports.createEvent;

package/dist/factories/eventDefaults.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file The standard event types of the browser, and how the browser creates them.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+/**
+ * How the browser creates an event of a standard type: whether it bubbles, whether it can be cancelled, whether it
+ * crosses the boundary of a shadow tree, and which kind of event object it is.
+ * @typedef {Object} EventDefinition
+ * @property {boolean} bubbles - After the target, the event goes back up through the ancestors (the capture phase, going down, always happens)
+ * @property {boolean} cancelable - preventDefault() can stop the default action
+ * @property {boolean} composed - The event crosses the boundary of a shadow tree
+ * @property {string} interface - The kind of event object: Event, UIEvent, MouseEvent, PointerEvent, KeyboardEvent, FocusEvent, InputEvent or CustomEvent
+ */
+export type EventDefinition = {
+    bubbles: boolean;
+    cancelable: boolean;
+    composed: boolean;
+    interface: 'Event' | 'UIEvent' | 'MouseEvent' | 'PointerEvent' | 'KeyboardEvent' | 'FocusEvent' | 'InputEvent' | 'CustomEvent';
+};
+/**
+ * The events which the browser itself creates (for a user action, or for something like element.click()) have these
+ * options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
+ * for them, which is why createEvent only uses this table when it is told the browser is creating the event.
+ * The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.
+ * @type {Object.<string, EventDefinition>}
+ */
+export declare const eventDefaults: {
+    [type: string]: EventDefinition;
+};
+export default eventDefaults;

package/dist/factories/eventDefaults.js

@@ -0,0 +1,105 @@
+'use strict'
+
+/**
+ * @file The standard event types of the browser, and how the browser creates them.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.eventDefaults = void 0
+const define = (bubbles, cancelable, composed, eventInterface = 'Event') => ({
+  bubbles,
+  cancelable,
+  composed,
+  interface: eventInterface
+})
+/**
+ * The events which the browser itself creates (for a user action, or for something like element.click()) have these
+ * options. A script which creates an event with the constructor gets none of them (everything is false) unless it asks
+ * for them, which is why createEvent only uses this table when it is told the browser is creating the event.
+ * The values follow the UI Events, HTML, Pointer Events, Clipboard, Drag and Drop, Touch and CSS specifications.
+ * @type {Object.<string, EventDefinition>}
+ */
+exports.eventDefaults = {
+  // Mouse (UI Events)
+  click: define(true, true, true, 'MouseEvent'),
+  auxclick: define(true, true, true, 'MouseEvent'),
+  dblclick: define(true, true, true, 'MouseEvent'),
+  contextmenu: define(true, true, true, 'MouseEvent'),
+  mousedown: define(true, true, true, 'MouseEvent'),
+  mouseup: define(true, true, true, 'MouseEvent'),
+  mousemove: define(true, true, true, 'MouseEvent'),
+  mouseover: define(true, true, true, 'MouseEvent'),
+  mouseout: define(true, true, true, 'MouseEvent'),
+  mouseenter: define(false, false, true, 'MouseEvent'),
+  mouseleave: define(false, false, true, 'MouseEvent'),
+  wheel: define(true, true, true, 'MouseEvent'),
+  // Pointer (Pointer Events)
+  pointerdown: define(true, true, true, 'PointerEvent'),
+  pointerup: define(true, true, true, 'PointerEvent'),
+  pointermove: define(true, true, true, 'PointerEvent'),
+  pointerover: define(true, true, true, 'PointerEvent'),
+  pointerout: define(true, true, true, 'PointerEvent'),
+  pointerenter: define(false, false, true, 'PointerEvent'),
+  pointerleave: define(false, false, true, 'PointerEvent'),
+  pointercancel: define(true, false, true, 'PointerEvent'),
+  gotpointercapture: define(true, false, true, 'PointerEvent'),
+  lostpointercapture: define(true, false, true, 'PointerEvent'),
+  // Keyboard (UI Events)
+  keydown: define(true, true, true, 'KeyboardEvent'),
+  keypress: define(true, true, true, 'KeyboardEvent'),
+  keyup: define(true, true, true, 'KeyboardEvent'),
+  // Focus (UI Events): focus and blur do not bubble, focusin and focusout do
+  focus: define(false, false, true, 'FocusEvent'),
+  blur: define(false, false, true, 'FocusEvent'),
+  focusin: define(true, false, true, 'FocusEvent'),
+  focusout: define(true, false, true, 'FocusEvent'),
+  // Forms (HTML, Input Events)
+  beforeinput: define(true, true, true, 'InputEvent'),
+  input: define(true, false, true, 'InputEvent'),
+  change: define(true, false, false),
+  select: define(true, false, false),
+  submit: define(true, true, false),
+  reset: define(true, true, false),
+  invalid: define(false, true, false),
+  toggle: define(false, false, false),
+  // Loading and the page (HTML)
+  load: define(false, false, false),
+  error: define(false, false, false),
+  abort: define(false, false, false),
+  scroll: define(false, false, false),
+  scrollend: define(false, false, false),
+  resize: define(false, false, false),
+  DOMContentLoaded: define(true, false, false),
+  readystatechange: define(false, false, false),
+  visibilitychange: define(true, false, false),
+  // Clipboard
+  copy: define(true, true, true),
+  cut: define(true, true, true),
+  paste: define(true, true, true),
+  // Drag and drop
+  drag: define(true, true, true, 'MouseEvent'),
+  dragstart: define(true, true, true, 'MouseEvent'),
+  dragend: define(true, false, true, 'MouseEvent'),
+  dragenter: define(true, true, true, 'MouseEvent'),
+  dragover: define(true, true, true, 'MouseEvent'),
+  dragleave: define(true, false, true, 'MouseEvent'),
+  drop: define(true, true, true, 'MouseEvent'),
+  // Touch
+  touchstart: define(true, true, true, 'UIEvent'),
+  touchmove: define(true, true, true, 'UIEvent'),
+  touchend: define(true, true, true, 'UIEvent'),
+  touchcancel: define(true, false, true, 'UIEvent'),
+  // Animations and transitions (CSS)
+  animationstart: define(true, false, false),
+  animationiteration: define(true, false, false),
+  animationend: define(true, false, false),
+  animationcancel: define(true, false, false),
+  transitionrun: define(true, false, false),
+  transitionstart: define(true, false, false),
+  transitionend: define(true, false, false),
+  transitioncancel: define(true, false, false)
+}
+exports.default = exports.eventDefaults

package/dist/factories/eventDefaults.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.eventDefaults=void 0;const define=(e,n,t,i="Event")=>({bubbles:e,cancelable:n,composed:t,interface:i});exports.eventDefaults={click:define(!0,!0,!0,"MouseEvent"),auxclick:define(!0,!0,!0,"MouseEvent"),dblclick:define(!0,!0,!0,"MouseEvent"),contextmenu:define(!0,!0,!0,"MouseEvent"),mousedown:define(!0,!0,!0,"MouseEvent"),mouseup:define(!0,!0,!0,"MouseEvent"),mousemove:define(!0,!0,!0,"MouseEvent"),mouseover:define(!0,!0,!0,"MouseEvent"),mouseout:define(!0,!0,!0,"MouseEvent"),mouseenter:define(!1,!1,!0,"MouseEvent"),mouseleave:define(!1,!1,!0,"MouseEvent"),wheel:define(!0,!0,!0,"MouseEvent"),pointerdown:define(!0,!0,!0,"PointerEvent"),pointerup:define(!0,!0,!0,"PointerEvent"),pointermove:define(!0,!0,!0,"PointerEvent"),pointerover:define(!0,!0,!0,"PointerEvent"),pointerout:define(!0,!0,!0,"PointerEvent"),pointerenter:define(!1,!1,!0,"PointerEvent"),pointerleave:define(!1,!1,!0,"PointerEvent"),pointercancel:define(!0,!1,!0,"PointerEvent"),gotpointercapture:define(!0,!1,!0,"PointerEvent"),lostpointercapture:define(!0,!1,!0,"PointerEvent"),keydown:define(!0,!0,!0,"KeyboardEvent"),keypress:define(!0,!0,!0,"KeyboardEvent"),keyup:define(!0,!0,!0,"KeyboardEvent"),focus:define(!1,!1,!0,"FocusEvent"),blur:define(!1,!1,!0,"FocusEvent"),focusin:define(!0,!1,!0,"FocusEvent"),focusout:define(!0,!1,!0,"FocusEvent"),beforeinput:define(!0,!0,!0,"InputEvent"),input:define(!0,!1,!0,"InputEvent"),change:define(!0,!1,!1),select:define(!0,!1,!1),submit:define(!0,!0,!1),reset:define(!0,!0,!1),invalid:define(!1,!0,!1),toggle:define(!1,!1,!1),load:define(!1,!1,!1),error:define(!1,!1,!1),abort:define(!1,!1,!1),scroll:define(!1,!1,!1),scrollend:define(!1,!1,!1),resize:define(!1,!1,!1),DOMContentLoaded:define(!0,!1,!1),readystatechange:define(!1,!1,!1),visibilitychange:define(!0,!1,!1),copy:define(!0,!0,!0),cut:define(!0,!0,!0),paste:define(!0,!0,!0),drag:define(!0,!0,!0,"MouseEvent"),dragstart:define(!0,!0,!0,"MouseEvent"),dragend:define(!0,!1,!0,"MouseEvent"),dragenter:define(!0,!0,!0,"MouseEvent"),dragover:define(!0,!0,!0,"MouseEvent"),dragleave:define(!0,!1,!0,"MouseEvent"),drop:define(!0,!0,!0,"MouseEvent"),touchstart:define(!0,!0,!0,"UIEvent"),touchmove:define(!0,!0,!0,"UIEvent"),touchend:define(!0,!0,!0,"UIEvent"),touchcancel:define(!0,!1,!0,"UIEvent"),animationstart:define(!0,!1,!1),animationiteration:define(!0,!1,!1),animationend:define(!0,!1,!1),animationcancel:define(!0,!1,!1),transitionrun:define(!0,!1,!1),transitionstart:define(!0,!1,!1),transitionend:define(!0,!1,!1),transitioncancel:define(!0,!1,!1)},exports.default=exports.eventDefaults;

package/dist/factories.d.ts

@@ -1,5 +1,11 @@
 declare const _default: {
     generateNode: () => typeof import("./factories/generateNode").NodeFactory;
     nodeListFactory: (innerList?: import("collect-your-stuff/dist/collections/linked-tree-list/TreeLinker").TreeLinker | null) => import("./classes/PseudoNodeList").PseudoNodeList;
+    createEvent: (type: string, init?: {
+        [option: string]: any;
+    }, { browser, trusted }?: import("./factories/createEvent").CreateEventOptions) => import("./main").PseudoEvent;
+    eventDefaults: {
+        [type: string]: import("./factories/eventDefaults").EventDefinition;
+    };
 };
 export default _default;

package/dist/factories.js

@@ -17,7 +17,11 @@ Object.defineProperty(exports, '__esModule', {
  */
 const generateNode_1 = __importDefault(require('./factories/generateNode'))
 const generateNodeList_1 = __importDefault(require('./factories/generateNodeList'))
+const createEvent_1 = __importDefault(require('./factories/createEvent'))
+const eventDefaults_1 = __importDefault(require('./factories/eventDefaults'))
 exports.default = {
   generateNode: generateNode_1.default,
-  nodeListFactory: generateNodeList_1.default
+  nodeListFactory: generateNodeList_1.default,
+  createEvent: createEvent_1.default,
+  eventDefaults: eventDefaults_1.default
 }

package/dist/factories.min.js

@@ -1 +1 @@
-"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const generateNode_1=__importDefault(require("./factories/generateNode")),generateNodeList_1=__importDefault(require("./factories/generateNodeList"));exports.default={generateNode:generateNode_1.default,nodeListFactory:generateNodeList_1.default};
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const generateNode_1=__importDefault(require("./factories/generateNode")),generateNodeList_1=__importDefault(require("./factories/generateNodeList")),createEvent_1=__importDefault(require("./factories/createEvent")),eventDefaults_1=__importDefault(require("./factories/eventDefaults"));exports.default={generateNode:generateNode_1.default,nodeListFactory:generateNodeList_1.default,createEvent:createEvent_1.default,eventDefaults:eventDefaults_1.default};

package/dist/functions/activeElement.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Find the element which has the focus in a tree.
+ * @function getActiveElement
+ * @param {Object} root The root node of the tree
+ * @returns {Object|null}
+ */
+export declare const getActiveElement: (root: object) => any | null;
+/**
+ * Remember the element which has the focus in a tree.
+ * @function setActiveElement
+ * @param {Object} root The root node of the tree
+ * @param {Object|null} element The element which now has the focus, or null when nothing has it
+ */
+export declare const setActiveElement: (root: object, element: any | null) => void;

package/dist/functions/activeElement.js

@@ -0,0 +1,33 @@
+'use strict'
+
+require('core-js/modules/esnext.weak-map.delete-all.js')
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.setActiveElement = exports.getActiveElement = void 0
+/**
+ * The element which has the focus, kept for each tree (the root node of the tree it is in), like document.activeElement.
+ */
+const focused = new WeakMap()
+/**
+ * Find the element which has the focus in a tree.
+ * @function getActiveElement
+ * @param {Object} root The root node of the tree
+ * @returns {Object|null}
+ */
+const getActiveElement = root => focused.get(root) || null
+exports.getActiveElement = getActiveElement
+/**
+ * Remember the element which has the focus in a tree.
+ * @function setActiveElement
+ * @param {Object} root The root node of the tree
+ * @param {Object|null} element The element which now has the focus, or null when nothing has it
+ */
+const setActiveElement = (root, element) => {
+  if (element === null) {
+    focused.delete(root)
+  } else {
+    focused.set(root, element)
+  }
+}
+exports.setActiveElement = setActiveElement

package/dist/functions/activeElement.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.setActiveElement=exports.getActiveElement=void 0;const focused=new WeakMap,getActiveElement=e=>focused.get(e)||null;exports.getActiveElement=getActiveElement;const setActiveElement=(e,t)=>{null===t?focused.delete(e):focused.set(e,t)};exports.setActiveElement=setActiveElement;

package/dist/functions/modifierState.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The modifier keys which were held down when a mouse or keyboard event happened.
+ * @typedef {Object} ModifierKeys
+ * @property {boolean} ctrlKey
+ * @property {boolean} shiftKey
+ * @property {boolean} altKey
+ * @property {boolean} metaKey
+ */
+export type ModifierKeys = {
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+};
+/**
+ * Pick the modifier keys out of the init object of an event.
+ * @function modifierKeys
+ * @param {Object} [init={}] The init of an event
+ * @returns {ModifierKeys}
+ */
+export declare const modifierKeys: (init?: any) => ModifierKeys;
+/**
+ * Answer getModifierState for a set of held modifier keys.
+ * @function modifierState
+ * @param {ModifierKeys} keys The modifier keys which were held down
+ * @param {string} key The name of the modifier (Control, Shift, Alt or Meta)
+ * @returns {boolean}
+ */
+export declare const modifierState: (keys: ModifierKeys, key: string) => boolean;

package/dist/functions/modifierState.js

@@ -0,0 +1,41 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.modifierState = exports.modifierKeys = void 0
+/**
+ * Pick the modifier keys out of the init object of an event.
+ * @function modifierKeys
+ * @param {Object} [init={}] The init of an event
+ * @returns {ModifierKeys}
+ */
+const modifierKeys = (init = {}) => ({
+  ctrlKey: !!init.ctrlKey,
+  shiftKey: !!init.shiftKey,
+  altKey: !!init.altKey,
+  metaKey: !!init.metaKey
+})
+exports.modifierKeys = modifierKeys
+/**
+ * Answer getModifierState for a set of held modifier keys.
+ * @function modifierState
+ * @param {ModifierKeys} keys The modifier keys which were held down
+ * @param {string} key The name of the modifier (Control, Shift, Alt or Meta)
+ * @returns {boolean}
+ */
+const modifierState = (keys, key) => {
+  switch (key) {
+    case 'Control':
+      return keys.ctrlKey
+    case 'Shift':
+      return keys.shiftKey
+    case 'Alt':
+      return keys.altKey
+    case 'Meta':
+      return keys.metaKey
+    default:
+      return false
+  }
+}
+exports.modifierState = modifierState

package/dist/functions/modifierState.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.modifierState=exports.modifierKeys=void 0;const modifierKeys=(e={})=>({ctrlKey:!!e.ctrlKey,shiftKey:!!e.shiftKey,altKey:!!e.altKey,metaKey:!!e.metaKey});exports.modifierKeys=modifierKeys;const modifierState=(e,t)=>{switch(t){case"Control":return e.ctrlKey;case"Shift":return e.shiftKey;case"Alt":return e.altKey;case"Meta":return e.metaKey;default:return!1}};exports.modifierState=modifierState;

package/dist/main.d.ts

@@ -10,6 +10,17 @@ import { ElementService as PseudoElement } from './services/ElementService';
 import { HTMLElementService as PseudoHTMLElement } from './services/HTMLElementService';
 import PseudoHTMLDocument from './classes/PseudoHTMLDocument';
 import generateDocument from './factories/generateDocument';
+import createEvent from './factories/createEvent';
+import eventDefaults from './factories/eventDefaults';
+import { UIEventService as PseudoUIEvent } from './services/UIEventService';
+import { MouseEventService as PseudoMouseEvent } from './services/MouseEventService';
+import { PointerEventService as PseudoPointerEvent } from './services/PointerEventService';
+import { KeyboardEventService as PseudoKeyboardEvent } from './services/KeyboardEventService';
+import { FocusEventService as PseudoFocusEvent } from './services/FocusEventService';
+import { InputEventService as PseudoInputEvent } from './services/InputEventService';
+import { CustomEventService as PseudoCustomEvent } from './services/CustomEventService';
+import simulate from './simulate';
+import { TextService as PseudoText, CommentService as PseudoComment } from './services/NodeService';
 /**
  * All methods exported from this module are encapsulated within pseudoDom.
  * @author Joshua Heagle <joshuaheagle@gmail.com>
@@ -18,12 +29,35 @@ import generateDocument from './factories/generateDocument';
  */
 declare const pseudoDom: {
     generateDocument: (root: Window | any, context?: object) => Window | PseudoEventTarget;
+    createEvent: (type: string, init?: {
+        [option: string]: any;
+    }, { browser, trusted }?: import("./factories/createEvent").CreateEventOptions) => PseudoEvent;
+    eventDefaults: {
+        [type: string]: import("./factories/eventDefaults").EventDefinition;
+    };
+    simulate: {
+        click: (element: any, init?: {
+            [option: string]: any;
+        }) => boolean;
+        keyPress: (element: any, key: string, init?: {
+            [option: string]: any;
+        }) => boolean;
+    };
     PseudoEvent: typeof PseudoEvent;
+    PseudoUIEvent: typeof PseudoUIEvent;
+    PseudoMouseEvent: typeof PseudoMouseEvent;
+    PseudoPointerEvent: typeof PseudoPointerEvent;
+    PseudoKeyboardEvent: typeof PseudoKeyboardEvent;
+    PseudoFocusEvent: typeof PseudoFocusEvent;
+    PseudoInputEvent: typeof PseudoInputEvent;
+    PseudoCustomEvent: typeof PseudoCustomEvent;
     PseudoEventTarget: typeof PseudoEventTarget;
     PseudoNode: typeof PseudoNode;
+    PseudoText: typeof PseudoText;
+    PseudoComment: typeof PseudoComment;
     PseudoElement: typeof PseudoElement;
     PseudoHTMLElement: typeof PseudoHTMLElement;
     PseudoHTMLDocument: typeof PseudoHTMLDocument;
 };
-export { generateDocument, PseudoEvent, PseudoEventTarget, PseudoNode, PseudoElement, PseudoHTMLElement, PseudoHTMLDocument };
+export { generateDocument, createEvent, eventDefaults, simulate, PseudoEvent, PseudoUIEvent, PseudoMouseEvent, PseudoPointerEvent, PseudoKeyboardEvent, PseudoFocusEvent, PseudoInputEvent, PseudoCustomEvent, PseudoEventTarget, PseudoNode, PseudoText, PseudoComment, PseudoElement, PseudoHTMLElement, PseudoHTMLDocument };
 export default pseudoDom;