pseudo-dom 0.1.0

package/dist/services/AttrService.js

@@ -0,0 +1,57 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.AttrService = void 0
+const NodeService_1 = require('./NodeService')
+/**
+ * Simulate the behaviour of the Attr Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments NodeService
+ */
+class AttrService extends NodeService_1.NodeService {
+  /**
+   * @param {string} name The name of the attribute
+   * @param {string} [value=''] The value of the attribute
+   * @param {PseudoElement|null} [ownerElement=null] The element which has this attribute
+   * @param {string} [namespaceURI=''] The namespace of the attribute
+   * @param {string|null} [prefix=null] The namespace prefix of the attribute
+   * @constructor
+   */
+  constructor (name = '', value = '', ownerElement = null, namespaceURI = '', prefix = null) {
+    super()
+    this.attributeName = name
+    this.value = value
+    this.element = ownerElement
+    this.namespace = namespaceURI
+    this.namespacePrefix = prefix
+    this.nodeNameValue = name
+  }
+
+  get nodeType () {
+    return NodeService_1.NodeService.ATTRIBUTE_NODE
+  }
+
+  get localName () {
+    return this.attributeName
+  }
+
+  get name () {
+    return this.namespacePrefix ? `${this.namespacePrefix}:${this.attributeName}` : this.attributeName
+  }
+
+  get namespaceURI () {
+    return this.namespace
+  }
+
+  get ownerElement () {
+    return this.element
+  }
+
+  get prefix () {
+    return this.namespacePrefix
+  }
+}
+exports.AttrService = AttrService

package/dist/services/AttrService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.AttrService=void 0;const NodeService_1=require("./NodeService");class AttrService extends NodeService_1.NodeService{constructor(e="",t="",r=null,i="",s=null){super(),this.attributeName=e,this.value=t,this.element=r,this.namespace=i,this.namespacePrefix=s,this.nodeNameValue=e}get nodeType(){return NodeService_1.NodeService.ATTRIBUTE_NODE}get localName(){return this.attributeName}get name(){return this.namespacePrefix?`${this.namespacePrefix}:${this.attributeName}`:this.attributeName}get namespaceURI(){return this.namespace}get ownerElement(){return this.element}get prefix(){return this.namespacePrefix}}exports.AttrService=AttrService;

package/dist/services/DOMTokenListService.d.ts

@@ -0,0 +1,33 @@
+import { PseudoDOMTokenList } from '../interfaces/PseudoDOMTokenList';
+/**
+ * Simulate the behaviour of the DOMTokenList Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ */
+export declare class DOMTokenListService implements PseudoDOMTokenList {
+    private tokens;
+    private readonly onChange;
+    /**
+     * @param {string} [value=''] The space separated tokens to start with
+     * @param {function(string): void} [onChange] Called with the new value whenever the tokens change
+     * @constructor
+     */
+    constructor(value?: string, onChange?: (value: string) => void);
+    private static parse;
+    private update;
+    private static validate;
+    get length(): number;
+    get value(): string;
+    set value(value: string);
+    item(index: number): string | null;
+    contains(token: string): boolean;
+    add(...tokens: string[]): void;
+    remove(...tokens: string[]): void;
+    replace(oldToken: string, newToken: string): boolean;
+    supports(token: string): boolean;
+    toggle(token: string, force?: boolean): boolean;
+    entries(): Iterator<[number, string]>;
+    forEach(callback: Function, thisArg?: any): void;
+    keys(): Iterator<number>;
+    values(): Iterator<string>;
+}

package/dist/services/DOMTokenListService.js

@@ -0,0 +1,117 @@
+'use strict'
+
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.filter.js')
+require('core-js/modules/esnext.iterator.for-each.js')
+require('core-js/modules/esnext.iterator.map.js')
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.DOMTokenListService = void 0
+/**
+ * Simulate the behaviour of the DOMTokenList Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ */
+class DOMTokenListService {
+  /**
+   * @param {string} [value=''] The space separated tokens to start with
+   * @param {function(string): void} [onChange] Called with the new value whenever the tokens change
+   * @constructor
+   */
+  constructor (value = '', onChange = () => undefined) {
+    this.tokens = DOMTokenListService.parse(value)
+    this.onChange = onChange
+  }
+
+  static parse (value) {
+    return (value || '').split(/\s+/).filter((token, index, tokens) => token !== '' && tokens.indexOf(token) === index)
+  }
+
+  update (tokens) {
+    this.tokens = tokens
+    this.onChange(this.value)
+  }
+
+  static validate (token) {
+    if (token === '') {
+      throw new SyntaxError('The token provided must not be empty.')
+    }
+    if (/\s/.test(token)) {
+      throw new Error('The token provided contains whitespace.')
+    }
+  }
+
+  get length () {
+    return this.tokens.length
+  }
+
+  get value () {
+    return this.tokens.join(' ')
+  }
+
+  set value (value) {
+    this.update(DOMTokenListService.parse(value))
+  }
+
+  item (index) {
+    return index >= 0 && index < this.tokens.length ? this.tokens[index] : null
+  }
+
+  contains (token) {
+    return this.tokens.indexOf(token) >= 0
+  }
+
+  add (...tokens) {
+    tokens.forEach(DOMTokenListService.validate)
+    this.update(this.tokens.concat(tokens).filter((token, index, all) => all.indexOf(token) === index))
+  }
+
+  remove (...tokens) {
+    tokens.forEach(DOMTokenListService.validate)
+    this.update(this.tokens.filter(token => tokens.indexOf(token) < 0))
+  }
+
+  replace (oldToken, newToken) {
+    DOMTokenListService.validate(oldToken)
+    DOMTokenListService.validate(newToken)
+    if (!this.contains(oldToken)) {
+      return false
+    }
+    this.update(this.tokens.map(token => token === oldToken ? newToken : token).filter((token, index, all) => all.indexOf(token) === index))
+    return true
+  }
+
+  supports (token) {
+    // There is no list of supported tokens for arbitrary attributes, so like the DOM (for those) this is unsupported
+    throw new TypeError(`Failed to execute 'supports' on 'DOMTokenList': DOMTokenList has no supported tokens (${token}).`)
+  }
+
+  toggle (token, force) {
+    DOMTokenListService.validate(token)
+    const shouldHave = typeof force === 'boolean' ? force : !this.contains(token)
+    if (shouldHave) {
+      this.add(token)
+    } else {
+      this.remove(token)
+    }
+    return shouldHave
+  }
+
+  entries () {
+    return this.tokens.map((token, index) => [index, token])[Symbol.iterator]()
+  }
+
+  forEach (callback, thisArg) {
+    this.tokens.forEach((token, index) => callback.call(thisArg, token, index, this))
+  }
+
+  keys () {
+    return this.tokens.map((token, index) => index)[Symbol.iterator]()
+  }
+
+  values () {
+    return this.tokens.slice()[Symbol.iterator]()
+  }
+}
+exports.DOMTokenListService = DOMTokenListService

package/dist/services/DOMTokenListService.min.js

@@ -0,0 +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.for-each.js"),require("core-js/modules/esnext.iterator.map.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.DOMTokenListService=void 0;class DOMTokenListService{constructor(e="",t=()=>{}){this.tokens=DOMTokenListService.parse(e),this.onChange=t}static parse(e){return(e||"").split(/\s+/).filter((e,t,s)=>""!==e&&s.indexOf(e)===t)}update(e){this.tokens=e,this.onChange(this.value)}static validate(e){if(""===e)throw new SyntaxError("The token provided must not be empty.");if(/\s/.test(e))throw new Error("The token provided contains whitespace.")}get length(){return this.tokens.length}get value(){return this.tokens.join(" ")}set value(e){this.update(DOMTokenListService.parse(e))}item(e){return e>=0&&e<this.tokens.length?this.tokens[e]:null}contains(e){return this.tokens.indexOf(e)>=0}add(...e){e.forEach(DOMTokenListService.validate),this.update(this.tokens.concat(e).filter((e,t,s)=>s.indexOf(e)===t))}remove(...e){e.forEach(DOMTokenListService.validate),this.update(this.tokens.filter(t=>e.indexOf(t)<0))}replace(e,t){return DOMTokenListService.validate(e),DOMTokenListService.validate(t),!!this.contains(e)&&(this.update(this.tokens.map(s=>s===e?t:s).filter((e,t,s)=>s.indexOf(e)===t)),!0)}supports(e){throw new TypeError(`Failed to execute 'supports' on 'DOMTokenList': DOMTokenList has no supported tokens (${e}).`)}toggle(e,t){DOMTokenListService.validate(e);const s="boolean"==typeof t?t:!this.contains(e);return s?this.add(e):this.remove(e),s}entries(){return this.tokens.map((e,t)=>[t,e])[Symbol.iterator]()}forEach(e,t){this.tokens.forEach((s,r)=>e.call(t,s,r,this))}keys(){return this.tokens.map((e,t)=>t)[Symbol.iterator]()}values(){return this.tokens.slice()[Symbol.iterator]()}}exports.DOMTokenListService=DOMTokenListService;

package/dist/services/DocumentFragmentService.d.ts

@@ -0,0 +1,4 @@
+import { NodeService } from './NodeService';
+import { PseudoDocumentFragment } from '../interfaces/PseudoDocumentFragment';
+export declare class DocumentFragmentService extends NodeService implements PseudoDocumentFragment {
+}

package/dist/services/DocumentFragmentService.js

@@ -0,0 +1,9 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.DocumentFragmentService = void 0
+const NodeService_1 = require('./NodeService')
+class DocumentFragmentService extends NodeService_1.NodeService {}
+exports.DocumentFragmentService = DocumentFragmentService

package/dist/services/DocumentFragmentService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DocumentFragmentService=void 0;const NodeService_1=require("./NodeService");class DocumentFragmentService extends NodeService_1.NodeService{}exports.DocumentFragmentService=DocumentFragmentService;

package/dist/services/DocumentService.d.ts

@@ -0,0 +1,4 @@
+import { NodeService } from './NodeService';
+import { PseudoDocument } from '../interfaces/PseudoDocument';
+export declare class DocumentService extends NodeService implements PseudoDocument {
+}

package/dist/services/DocumentService.js

@@ -0,0 +1,9 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.DocumentService = void 0
+const NodeService_1 = require('./NodeService')
+class DocumentService extends NodeService_1.NodeService {}
+exports.DocumentService = DocumentService

package/dist/services/DocumentService.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DocumentService=void 0;const NodeService_1=require("./NodeService");class DocumentService extends NodeService_1.NodeService{}exports.DocumentService=DocumentService;

package/dist/services/ElementService.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @file Substitute for the DOM Element Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { PseudoNode } from '../interfaces/PseudoNode';
+import { NodeService } from './NodeService';
+import { PseudoElement } from '../interfaces/PseudoElement';
+import { PseudoNamedNodeMap } from '../interfaces/PseudoNamedNodeMap';
+import { PseudoDOMTokenList } from '../interfaces/PseudoDOMTokenList';
+type attribute = {
+    name: string;
+    value: any;
+};
+/**
+ * Simulate the behaviour of the Element Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments PseudoNode
+ * @property {string} tagName
+ * @property {string} className
+ * @property {string} id
+ * @property {string} innerHtml
+ * @property {Array} attributes
+ * @property {function} hasAttribute
+ * @property {function} setAttribute
+ * @property {function} getAttribute
+ * @property {function} removeAttribute
+ */
+export declare class ElementService extends NodeService implements Partial<PseudoElement> {
+    id: string;
+    innerHTML: string;
+    type: string;
+    private readonly tag;
+    private readonly attributeList;
+    private readonly propertyAttributes;
+    private readonly tokenList;
+    /**
+     * @param {Object} [settings={}]
+     * @param {string} [settings.tagName=''] The name of the tag this element represents
+     * @param {Array<{name: string, value: *}>} [settings.attributes=[]] The attributes (also assigned as properties) to start with
+     * @param {PseudoNode|null} [settings.parent=null] The parent node
+     * @param {Array} [settings.children=[]] The values or nodes to start as children
+     * @constructor
+     */
+    constructor({ tagName, attributes, parent, children }?: {
+        tagName?: string;
+        attributes?: Array<attribute>;
+        parent?: PseudoNode | null;
+        children?: Array<any>;
+    });
+    get tagName(): string;
+    get nodeType(): number;
+    get attributes(): PseudoNamedNodeMap;
+    get classList(): PseudoDOMTokenList;
+    get className(): string;
+    set className(className: string);
+    /**
+     * Some elements have default behaviour, this registers it when the element is added.
+     * @returns {Function}
+     */
+    applyDefaultEvent(): Function;
+    /**
+     *
+     * @param {PseudoNode|ElementService} childElement
+     * @returns {PseudoNode}
+     */
+    appendChild(childElement: ElementService): PseudoNode;
+    /**
+     * Check whether the element has an attribute by that name.
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    hasAttribute(attributeName: string): boolean;
+    /**
+     * Set the value of an attribute, adding the attribute if it did not exist.
+     * @param {string} attributeName
+     * @param {string} attributeValue
+     * @returns {undefined}
+     */
+    setAttribute(attributeName: string, attributeValue: string): void;
+    /**
+     * Retrieve the value of an attribute.
+     * @param {string} attributeName
+     * @returns {string|null} The value, or null when there is no such attribute
+     */
+    getAttribute(attributeName: string): string | null;
+    /**
+     * Remove an attribute from the element.
+     * @param {string} attributeName
+     * @returns {undefined}
+     */
+    removeAttribute(attributeName: string): void;
+}
+export {};

package/dist/services/ElementService.js

@@ -0,0 +1,205 @@
+'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')
+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
+    : {
+        default: mod
+      }
+}
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.ElementService = void 0
+const generateNodeList_1 = __importDefault(require('../factories/generateNodeList'))
+const TreeLinker_1 = require('collect-your-stuff/dist/collections/linked-tree-list/TreeLinker')
+const NodeService_1 = require('./NodeService')
+const AttrService_1 = require('./AttrService')
+const DOMTokenListService_1 = require('./DOMTokenListService')
+const NamedNodeMapService_1 = require('./NamedNodeMapService')
+const getParentNodesFromAttribute_1 = __importDefault(require('../functions/getParentNodesFromAttribute'))
+/**
+ * Simulate the behaviour of the Element Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments PseudoNode
+ * @property {string} tagName
+ * @property {string} className
+ * @property {string} id
+ * @property {string} innerHtml
+ * @property {Array} attributes
+ * @property {function} hasAttribute
+ * @property {function} setAttribute
+ * @property {function} getAttribute
+ * @property {function} removeAttribute
+ */
+class ElementService extends NodeService_1.NodeService {
+  /**
+   * @param {Object} [settings={}]
+   * @param {string} [settings.tagName=''] The name of the tag this element represents
+   * @param {Array<{name: string, value: *}>} [settings.attributes=[]] The attributes (also assigned as properties) to start with
+   * @param {PseudoNode|null} [settings.parent=null] The parent node
+   * @param {Array} [settings.children=[]] The values or nodes to start as children
+   * @constructor
+   */
+  constructor ({
+    tagName = '',
+    attributes = [],
+    parent = null,
+    children = []
+  } = {}) {
+    super()
+    this.tokenList = new DOMTokenListService_1.DOMTokenListService()
+    this.parent = parent
+    this.children = (0, generateNodeList_1.default)(TreeLinker_1.TreeLinker.fromArray(children).head)
+    this.tag = tagName
+    this.attributeList = attributes.concat([{
+      name: 'className',
+      value: ''
+    }, {
+      name: 'id',
+      value: ''
+    }, {
+      name: 'innerHTML',
+      value: ''
+    }])
+    this.propertyAttributes = this.attributeList.map(({
+      name
+    }) => name)
+    this.attributeList.forEach(({
+      name,
+      value
+    }) => {
+      this[name] = value
+    })
+  }
+
+  get tagName () {
+    return this.tag
+  }
+
+  get nodeType () {
+    return NodeService_1.NodeService.ELEMENT_NODE
+  }
+
+  get attributes () {
+    return new NamedNodeMapService_1.NamedNodeMapService(this.attributeList.map(({
+      name,
+      value
+    }) => new AttrService_1.AttrService(name, String(value), this)))
+  }
+
+  get classList () {
+    return this.tokenList
+  }
+
+  get className () {
+    return this.tokenList.value
+  }
+
+  set className (className) {
+    this.tokenList.value = className
+  }
+
+  /**
+   * Some elements have default behaviour, this registers it when the element is added.
+   * @returns {Function}
+   */
+  applyDefaultEvent () {
+    let callback = event => undefined
+    switch (this.tagName) {
+      case 'form':
+        this.addEventListener('submit', callback)
+        break
+      case 'button':
+      case 'input':
+        if (/^(submit|image)$/i.test(this.type || '')) {
+          callback = event => {
+            const forms = (0, getParentNodesFromAttribute_1.default)('tagName', 'form', this)
+            if (forms.length) {
+              forms[0].submit()
+            }
+          }
+          super.setDefaultEvent('click', callback)
+        }
+    }
+    return callback
+  }
+
+  /**
+   *
+   * @param {PseudoNode|ElementService} childElement
+   * @returns {PseudoNode}
+   */
+  appendChild (childElement) {
+    super.appendChild(childElement)
+    childElement.applyDefaultEvent()
+    return childElement
+  }
+
+  /**
+   * Check whether the element has an attribute by that name.
+   * @param {string} attributeName
+   * @returns {boolean}
+   */
+  hasAttribute (attributeName) {
+    return this.attributeList.some(({
+      name
+    }) => name === attributeName)
+  }
+
+  /**
+   * Set the value of an attribute, adding the attribute if it did not exist.
+   * @param {string} attributeName
+   * @param {string} attributeValue
+   * @returns {undefined}
+   */
+  setAttribute (attributeName, attributeValue) {
+    const existing = this.attributeList.find(({
+      name
+    }) => name === attributeName)
+    if (existing) {
+      existing.value = attributeValue
+    } else {
+      this.attributeList.push({
+        name: attributeName,
+        value: attributeValue
+      })
+    }
+    if (this.propertyAttributes.indexOf(attributeName) >= 0) {
+      this[attributeName] = attributeValue
+    }
+  }
+
+  /**
+   * Retrieve the value of an attribute.
+   * @param {string} attributeName
+   * @returns {string|null} The value, or null when there is no such attribute
+   */
+  getAttribute (attributeName) {
+    const found = this.attributeList.find(({
+      name
+    }) => name === attributeName)
+    return found ? found.value : null
+  }
+
+  /**
+   * Remove an attribute from the element.
+   * @param {string} attributeName
+   * @returns {undefined}
+   */
+  removeAttribute (attributeName) {
+    const index = this.attributeList.findIndex(({
+      name
+    }) => name === attributeName)
+    if (index >= 0) {
+      this.attributeList.splice(index, 1)
+    }
+  }
+}
+exports.ElementService = ElementService

package/dist/services/ElementService.min.js

@@ -0,0 +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"),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}),exports.ElementService=void 0;const generateNodeList_1=__importDefault(require("../factories/generateNodeList")),TreeLinker_1=require("collect-your-stuff/dist/collections/linked-tree-list/TreeLinker"),NodeService_1=require("./NodeService"),AttrService_1=require("./AttrService"),DOMTokenListService_1=require("./DOMTokenListService"),NamedNodeMapService_1=require("./NamedNodeMapService"),getParentNodesFromAttribute_1=__importDefault(require("../functions/getParentNodesFromAttribute"));class ElementService extends NodeService_1.NodeService{constructor({tagName:e="",attributes:t=[],parent:r=null,children:i=[]}={}){super(),this.tokenList=new DOMTokenListService_1.DOMTokenListService,this.parent=r,this.children=(0,generateNodeList_1.default)(TreeLinker_1.TreeLinker.fromArray(i).head),this.tag=e,this.attributeList=t.concat([{name:"className",value:""},{name:"id",value:""},{name:"innerHTML",value:""}]),this.propertyAttributes=this.attributeList.map(({name:e})=>e),this.attributeList.forEach(({name:e,value:t})=>{this[e]=t})}get tagName(){return this.tag}get nodeType(){return NodeService_1.NodeService.ELEMENT_NODE}get attributes(){return new NamedNodeMapService_1.NamedNodeMapService(this.attributeList.map(({name:e,value:t})=>new AttrService_1.AttrService(e,String(t),this)))}get classList(){return this.tokenList}get className(){return this.tokenList.value}set className(e){this.tokenList.value=e}applyDefaultEvent(){let e=e=>{};switch(this.tagName){case"form":this.addEventListener("submit",e);break;case"button":case"input":/^(submit|image)$/i.test(this.type||"")&&(e=e=>{const t=(0,getParentNodesFromAttribute_1.default)("tagName","form",this);t.length&&t[0].submit()},super.setDefaultEvent("click",e))}return e}appendChild(e){return super.appendChild(e),e.applyDefaultEvent(),e}hasAttribute(e){return this.attributeList.some(({name:t})=>t===e)}setAttribute(e,t){const r=this.attributeList.find(({name:t})=>t===e);r?r.value=t:this.attributeList.push({name:e,value:t}),this.propertyAttributes.indexOf(e)>=0&&(this[e]=t)}getAttribute(e){const t=this.attributeList.find(({name:t})=>t===e);return t?t.value:null}removeAttribute(e){const t=this.attributeList.findIndex(({name:t})=>t===e);t>=0&&this.attributeList.splice(t,1)}}exports.ElementService=ElementService;

package/dist/services/EventService.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @file Substitute for the DOM Event Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { PseudoEventTarget } from '../interfaces/PseudoEventTarget';
+import { PseudoEvent } from '../interfaces/PseudoEvent';
+export type EventInner = {
+    currentTarget: PseudoEventTarget;
+    eventPhase: number;
+    target: PseudoEventTarget;
+    immediatePropagationStopped: boolean;
+    propagationStopped: boolean;
+};
+/**
+ * Simulate the behaviour of the Event Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @property {number} NONE
+ * @property {number} CAPTURING_PHASE
+ * @property {number} AT_TARGET
+ * @property {number} BUBBLING_PHASE
+ * @property {boolean} bubbles - A Boolean indicating whether the event bubbles up through the Dom or not.
+ * @property {boolean} cancelable - A Boolean indicating whether the event is cancelable.
+ * @property {boolean} composed - A Boolean value indicating whether the event can bubble across the boundary
+ * between the shadow Dom and the regular Dom.
+ * @property {function|PseudoEventTarget} currentTarget - A reference to the currently registered target for the event. This
+ * is the object to which the event is currently slated to be sent; it's possible this has been changed along the way
+ * through re-targeting.
+ * @property {boolean} defaultPrevented - Indicates whether event.preventDefault() has been called on the event.
+ * @property {boolean} immediatePropagationStopped - Flag that no further propagation should occur, including on current
+ * target.
+ * @property {boolean} propagationStopped - Flag that no further propagation should occur.
+ * @property {int} eventPhase - Indicates which phase of the event flow is being processed. Uses EventService constants.
+ * @property {EventTarget|PseudoEventTarget} target - A reference to the target to which the event was originally
+ * dispatched.
+ * @property {int} timeStamp - The time at which the event was created (in milliseconds). By specification, this
+ * value is time since epoch, but in reality browsers' definitions vary; in addition, work is underway to change this
+ * to be a DomHighResTimeStamp instead.
+ * @property {string} type - The name of the event (case-insensitive).
+ * @property {boolean} isTrusted - Indicates whether the event was initiated by the browser (after a user
+ * click for instance) or by a script (using an event creation method, like event.initEvent)
+ */
+export declare class EventService implements PseudoEvent {
+    static readonly NONE = 0;
+    static readonly CAPTURING_PHASE = 1;
+    static readonly AT_TARGET = 2;
+    static readonly BUBBLING_PHASE = 3;
+    private properties;
+    /**
+     *
+     * @param {string} typeArg
+     * @param {Object} [eventOptions={}]
+     * @param {boolean} [eventOptions.bubbles=true]
+     * @param {boolean} [eventOptions.cancelable=true]
+     * @param {boolean} [eventOptions.composed=true]
+     * @constructor
+     */
+    constructor(typeArg?: string, { bubbles, cancelable, composed }?: {
+        bubbles?: boolean;
+        cancelable?: boolean;
+        composed?: boolean;
+    });
+    get bubbles(): boolean;
+    get cancelable(): boolean;
+    get composed(): boolean;
+    get currentTarget(): PseudoEventTarget;
+    get defaultPrevented(): boolean;
+    get eventPhase(): number;
+    get isTrusted(): boolean;
+    get target(): PseudoEventTarget;
+    get timeStamp(): number;
+    get type(): string;
+    /**
+     * Scope several accessors inside the inner object. These are only intended for usage by other DOM classes.
+     * @returns {EventInner}
+     */
+    get inner(): EventInner;
+    /**
+     * Return an array of targets that will have the event executed open them. The order is based on the eventPhase
+     * @method
+     * @returns {Array.<PseudoEventTarget>}
+     */
+    composedPath(): Array<PseudoEventTarget>;
+    /**
+     * Cancels the event (if it is cancelable).
+     * @method
+     * @returns {null}
+     */
+    preventDefault(): null;
+    /**
+     * For this particular event, no other listener will be called.
+     * Neither those attached on the same element, nor those attached on elements which will be traversed later (in
+     * capture phase, for instance)
+     * @method
+     * @returns {null}
+     */
+    stopImmediatePropagation(): null;
+    /**
+     * Stops the propagation of events further along in the Dom.
+     * @method
+     * @returns {null}
+     */
+    stopPropagation(): null;
+    private setReadOnlyProperties;
+}