pseudo-dom 0.6.0 → 0.8.0

package/dist/services/HTMLElementService.js

@@ -1,163 +1,163 @@
-'use strict'
-
-const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
-  return mod && mod.__esModule
-    ? mod
-    : {
-        default: mod
-      }
-}
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.HTMLElementService = void 0
-const ElementService_1 = require('./ElementService')
-const createEvent_1 = __importDefault(require('../factories/createEvent'))
-const activeElement_1 = require('../functions/activeElement')
-/**
- * Simulate the behaviour of the HTMLElement Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments PseudoElement
- * @property {boolean} hidden - State of whether element is visible
- * @property {number} offsetHeight - The height of the element as offset by the parent element
- * @property {number} offsetLeft - The position of the left side of the element based on the parent element
- * @property {PseudoHTMLElement} offsetParent - A reference to the closest positioned parent element
- * @property {number} offsetTop - The position of the top side of the element based on the parent element
- * @property {number} offsetWidth - The width of the element as offset by the parent element
- * @property {Object} style - A container to define all applied inline-styles
- * @property {string} title - The title attribute which affects the text visible on hover
- */
-class HTMLElementService extends ElementService_1.ElementService {
-  /**
-   * Simulate the HTMLElement object when the Dom is not available
-   * @param {Object} [elementOptions={}]
-   * @param {string} [elementOptions.tagName='']
-   * @param {PseudoNode|Object} [elementOptions.parent={}]
-   * @param {Array} [elementOptions.children=[]]
-   * @constructor
-   */
-  constructor ({
-    tagName = '',
-    parent = null,
-    children = []
-  } = {}) {
-    super({
-      tagName,
-      attributes: [{
-        name: 'hidden',
-        value: false
-      }, {
-        name: 'offsetHeight',
-        value: 0
-      }, {
-        name: 'offsetLeft',
-        value: 0
-      }, {
-        name: 'offsetParent',
-        value: null
-      }, {
-        name: 'offsetTop',
-        value: 0
-      }, {
-        name: 'offsetWidth',
-        value: 0
-      }, {
-        name: 'style',
-        value: {}
-      }, {
-        name: 'title',
-        value: ''
-      }],
-      parent,
-      children
-    })
-  }
-
-  /**
-   * Whether this element can have the focus: form controls and links which are not disabled, and anything with a tabindex.
-   * @returns {boolean}
-   */
-  get canFocus () {
-    if (this.hasAttribute('disabled')) {
-      return false
-    }
-    switch (this.tagName) {
-      case 'button':
-      case 'select':
-      case 'textarea':
-        return true
-      case 'input':
-        return String(this.getAttribute('type') || '').toLowerCase() !== 'hidden'
-      case 'a':
-        return this.hasAttribute('href') || this.hasAttribute('tabindex')
-      default:
-        return this.hasAttribute('tabindex')
-    }
-  }
-
-  /**
-   * Click the element: a click event is sent to it, which bubbles and can be cancelled, like one from a user but a
-   * script made it (so it is not trusted). A disabled element does nothing.
-   */
-  click () {
-    if (this.hasAttribute('disabled')) {
-      return
-    }
-    this.dispatchEvent((0, createEvent_1.default)('click', {}, {
-      browser: true
-    }))
-  }
-
-  /**
-   * Give the element the focus. The element which had it gets blur then focusout, and this one gets focus then
-   * focusin (blur and focus do not bubble, focusin and focusout do). Nothing happens when the element cannot have the
-   * focus or already has it.
-   */
-  focus () {
-    const root = this.getRootNode()
-    const previous = (0, activeElement_1.getActiveElement)(root)
-    if (!this.canFocus || previous === this) {
-      return
-    }
-    const send = (target, type, relatedTarget) => {
-      target.dispatchEvent((0, createEvent_1.default)(type, {
-        relatedTarget
-      }, {
-        browser: true,
-        trusted: true
-      }))
-    }
-    if (previous) {
-      send(previous, 'blur', this)
-      send(previous, 'focusout', this)
-    }
-    (0, activeElement_1.setActiveElement)(root, this)
-    send(this, 'focus', previous)
-    send(this, 'focusin', previous)
-  }
-
-  /**
-   * Take the focus away from the element, when it has it: it gets blur then focusout.
-   */
-  blur () {
-    const root = this.getRootNode()
-    if ((0, activeElement_1.getActiveElement)(root) !== this) {
-      return
-    }
-    (0, activeElement_1.setActiveElement)(root, null)
-    this.dispatchEvent((0, createEvent_1.default)('blur', {
-      relatedTarget: null
-    }, {
-      browser: true,
-      trusted: true
-    }))
-    this.dispatchEvent((0, createEvent_1.default)('focusout', {
-      relatedTarget: null
-    }, {
-      browser: true,
-      trusted: true
-    }))
-  }
-}
-exports.HTMLElementService = HTMLElementService
+'use strict'
+
+const __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule
+    ? mod
+    : {
+        default: mod
+      }
+}
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.HTMLElementService = void 0
+const ElementService_1 = require('./ElementService')
+const createEvent_1 = __importDefault(require('../factories/createEvent'))
+const activeElement_1 = require('../functions/activeElement')
+/**
+ * Simulate the behaviour of the HTMLElement Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments PseudoElement
+ * @property {boolean} hidden - State of whether element is visible
+ * @property {number} offsetHeight - The height of the element as offset by the parent element
+ * @property {number} offsetLeft - The position of the left side of the element based on the parent element
+ * @property {PseudoHTMLElement} offsetParent - A reference to the closest positioned parent element
+ * @property {number} offsetTop - The position of the top side of the element based on the parent element
+ * @property {number} offsetWidth - The width of the element as offset by the parent element
+ * @property {Object} style - A container to define all applied inline-styles
+ * @property {string} title - The title attribute which affects the text visible on hover
+ */
+class HTMLElementService extends ElementService_1.ElementService {
+  /**
+   * Simulate the HTMLElement object when the Dom is not available
+   * @param {Object} [elementOptions={}]
+   * @param {string} [elementOptions.tagName='']
+   * @param {PseudoNode|Object} [elementOptions.parent={}]
+   * @param {Array} [elementOptions.children=[]]
+   * @constructor
+   */
+  constructor ({
+    tagName = '',
+    parent = null,
+    children = []
+  } = {}) {
+    super({
+      tagName,
+      attributes: [{
+        name: 'hidden',
+        value: false
+      }, {
+        name: 'offsetHeight',
+        value: 0
+      }, {
+        name: 'offsetLeft',
+        value: 0
+      }, {
+        name: 'offsetParent',
+        value: null
+      }, {
+        name: 'offsetTop',
+        value: 0
+      }, {
+        name: 'offsetWidth',
+        value: 0
+      }, {
+        name: 'style',
+        value: {}
+      }, {
+        name: 'title',
+        value: ''
+      }],
+      parent,
+      children
+    })
+  }
+
+  /**
+   * Whether this element can have the focus: form controls and links which are not disabled, and anything with a tabindex.
+   * @returns {boolean}
+   */
+  get canFocus () {
+    if (this.hasAttribute('disabled')) {
+      return false
+    }
+    switch (this.tagName) {
+      case 'button':
+      case 'select':
+      case 'textarea':
+        return true
+      case 'input':
+        return String(this.getAttribute('type') || '').toLowerCase() !== 'hidden'
+      case 'a':
+        return this.hasAttribute('href') || this.hasAttribute('tabindex')
+      default:
+        return this.hasAttribute('tabindex')
+    }
+  }
+
+  /**
+   * Click the element: a click event is sent to it, which bubbles and can be cancelled, like one from a user but a
+   * script made it (so it is not trusted). A disabled element does nothing.
+   */
+  click () {
+    if (this.hasAttribute('disabled')) {
+      return
+    }
+    this.dispatchEvent((0, createEvent_1.default)('click', {}, {
+      browser: true
+    }))
+  }
+
+  /**
+   * Give the element the focus. The element which had it gets blur then focusout, and this one gets focus then
+   * focusin (blur and focus do not bubble, focusin and focusout do). Nothing happens when the element cannot have the
+   * focus or already has it.
+   */
+  focus () {
+    const root = this.getRootNode()
+    const previous = (0, activeElement_1.getActiveElement)(root)
+    if (!this.canFocus || previous === this) {
+      return
+    }
+    const send = (target, type, relatedTarget) => {
+      target.dispatchEvent((0, createEvent_1.default)(type, {
+        relatedTarget
+      }, {
+        browser: true,
+        trusted: true
+      }))
+    }
+    if (previous) {
+      send(previous, 'blur', this)
+      send(previous, 'focusout', this)
+    }
+    (0, activeElement_1.setActiveElement)(root, this)
+    send(this, 'focus', previous)
+    send(this, 'focusin', previous)
+  }
+
+  /**
+   * Take the focus away from the element, when it has it: it gets blur then focusout.
+   */
+  blur () {
+    const root = this.getRootNode()
+    if ((0, activeElement_1.getActiveElement)(root) !== this) {
+      return
+    }
+    (0, activeElement_1.setActiveElement)(root, null)
+    this.dispatchEvent((0, createEvent_1.default)('blur', {
+      relatedTarget: null
+    }, {
+      browser: true,
+      trusted: true
+    }))
+    this.dispatchEvent((0, createEvent_1.default)('focusout', {
+      relatedTarget: null
+    }, {
+      browser: true,
+      trusted: true
+    }))
+  }
+}
+exports.HTMLElementService = HTMLElementService

package/dist/services/HTMLSlotElementService.d.ts

@@ -1,4 +1,4 @@
-import { PseudoHTMLSlotElement } from '../interfaces/PseudoHTMLSlotElement';
-import { HTMLElementService } from './HTMLElementService';
-export declare class HTMLSlotElementService extends HTMLElementService implements Partial<PseudoHTMLSlotElement> {
-}
+import { PseudoHTMLSlotElement } from '../interfaces/PseudoHTMLSlotElement';
+import { HTMLElementService } from './HTMLElementService';
+export declare class HTMLSlotElementService extends HTMLElementService implements Partial<PseudoHTMLSlotElement> {
+}

package/dist/services/HTMLSlotElementService.js

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

package/dist/services/InputEventService.d.ts

@@ -1,41 +1,41 @@
-/**
- * @file Substitute for the DOM InputEvent Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-import { UIEventInit, UIEventService } from './UIEventService';
-/**
- * The options for creating an input event, on top of the ones every UI event has.
- * @typedef {Object} InputEventInit
- * @property {string|null} [data=null] The characters which were entered
- * @property {string} [inputType=''] What kind of change it was, such as insertText
- * @property {boolean} [isComposing=false]
- */
-export type InputEventInit = UIEventInit & {
-    data?: string | null;
-    inputType?: string;
-    isComposing?: boolean;
-};
-/**
- * Simulate the behaviour of the InputEvent Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments UIEventService
- * @property {string|null} data
- * @property {string} inputType
- * @property {boolean} isComposing
- */
-export declare class InputEventService extends UIEventService {
-    private readonly inputData;
-    private readonly kind;
-    private readonly composing;
-    /**
-     * @param {string} [typeArg=''] The type of the event
-     * @param {InputEventInit} [init={}] The options for the event
-     * @constructor
-     */
-    constructor(typeArg?: string, init?: InputEventInit);
-    get data(): string | null;
-    get inputType(): string;
-    get isComposing(): boolean;
-}
+/**
+ * @file Substitute for the DOM InputEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { UIEventInit, UIEventService } from './UIEventService';
+/**
+ * The options for creating an input event, on top of the ones every UI event has.
+ * @typedef {Object} InputEventInit
+ * @property {string|null} [data=null] The characters which were entered
+ * @property {string} [inputType=''] What kind of change it was, such as insertText
+ * @property {boolean} [isComposing=false]
+ */
+export type InputEventInit = UIEventInit & {
+    data?: string | null;
+    inputType?: string;
+    isComposing?: boolean;
+};
+/**
+ * Simulate the behaviour of the InputEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string|null} data
+ * @property {string} inputType
+ * @property {boolean} isComposing
+ */
+export declare class InputEventService extends UIEventService {
+    private readonly inputData;
+    private readonly kind;
+    private readonly composing;
+    /**
+     * @param {string} [typeArg=''] The type of the event
+     * @param {InputEventInit} [init={}] The options for the event
+     * @constructor
+     */
+    constructor(typeArg?: string, init?: InputEventInit);
+    get data(): string | null;
+    get inputType(): string;
+    get isComposing(): boolean;
+}

package/dist/services/InputEventService.js

@@ -1,47 +1,47 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.InputEventService = void 0
-/**
- * @file Substitute for the DOM InputEvent Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-const UIEventService_1 = require('./UIEventService')
-/**
- * Simulate the behaviour of the InputEvent Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments UIEventService
- * @property {string|null} data
- * @property {string} inputType
- * @property {boolean} isComposing
- */
-class InputEventService extends UIEventService_1.UIEventService {
-  /**
-   * @param {string} [typeArg=''] The type of the event
-   * @param {InputEventInit} [init={}] The options for the event
-   * @constructor
-   */
-  constructor (typeArg = '', init = {}) {
-    super(typeArg, init)
-    this.inputData = typeof init.data === 'string' ? init.data : null
-    this.kind = init.inputType || ''
-    this.composing = !!init.isComposing
-  }
-
-  get data () {
-    return this.inputData
-  }
-
-  get inputType () {
-    return this.kind
-  }
-
-  get isComposing () {
-    return this.composing
-  }
-}
-exports.InputEventService = InputEventService
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.InputEventService = void 0
+/**
+ * @file Substitute for the DOM InputEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+const UIEventService_1 = require('./UIEventService')
+/**
+ * Simulate the behaviour of the InputEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string|null} data
+ * @property {string} inputType
+ * @property {boolean} isComposing
+ */
+class InputEventService extends UIEventService_1.UIEventService {
+  /**
+   * @param {string} [typeArg=''] The type of the event
+   * @param {InputEventInit} [init={}] The options for the event
+   * @constructor
+   */
+  constructor (typeArg = '', init = {}) {
+    super(typeArg, init)
+    this.inputData = typeof init.data === 'string' ? init.data : null
+    this.kind = init.inputType || ''
+    this.composing = !!init.isComposing
+  }
+
+  get data () {
+    return this.inputData
+  }
+
+  get inputType () {
+    return this.kind
+  }
+
+  get isComposing () {
+    return this.composing
+  }
+}
+exports.InputEventService = InputEventService

package/dist/services/KeyboardEventService.d.ts

@@ -1,70 +1,70 @@
-/**
- * @file Substitute for the DOM KeyboardEvent Class.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @version 1.0.0
- */
-import { UIEventInit, UIEventService } from './UIEventService';
-/**
- * The options for creating a keyboard event, on top of the ones every UI event has.
- * @typedef {Object} KeyboardEventInit
- * @property {string} [key=''] The value of the key, such as a or Enter
- * @property {string} [code=''] The physical key, such as KeyA or Enter
- * @property {number} [location=0] Where on the keyboard the key is (0 standard, 1 left, 2 right, 3 numeric pad)
- * @property {boolean} [repeat=false] The key is being held down
- * @property {boolean} [isComposing=false]
- * @property {boolean} [ctrlKey=false]
- * @property {boolean} [shiftKey=false]
- * @property {boolean} [altKey=false]
- * @property {boolean} [metaKey=false]
- */
-export type KeyboardEventInit = UIEventInit & {
-    key?: string;
-    code?: string;
-    location?: number;
-    repeat?: boolean;
-    isComposing?: boolean;
-    ctrlKey?: boolean;
-    shiftKey?: boolean;
-    altKey?: boolean;
-    metaKey?: boolean;
-};
-/**
- * Simulate the behaviour of the KeyboardEvent Class when there is no DOM available.
- * @author Joshua Heagle <joshuaheagle@gmail.com>
- * @class
- * @augments UIEventService
- * @property {string} key
- * @property {string} code
- * @property {number} location
- * @property {boolean} repeat
- * @property {boolean} isComposing
- */
-export declare class KeyboardEventService extends UIEventService {
-    private readonly keyValue;
-    private readonly keyCode;
-    private readonly keyLocation;
-    private readonly held;
-    private readonly composing;
-    private readonly modifiers;
-    /**
-     * @param {string} [typeArg=''] The type of the event
-     * @param {KeyboardEventInit} [init={}] The options for the event
-     * @constructor
-     */
-    constructor(typeArg?: string, init?: KeyboardEventInit);
-    get key(): string;
-    get code(): string;
-    get location(): number;
-    get repeat(): boolean;
-    get isComposing(): boolean;
-    get ctrlKey(): boolean;
-    get shiftKey(): boolean;
-    get altKey(): boolean;
-    get metaKey(): boolean;
-    /**
-     * Whether a modifier key was held down when the event happened.
-     * @param {string} key Control, Shift, Alt or Meta
-     * @returns {boolean}
-     */
-    getModifierState(key: string): boolean;
-}
+/**
+ * @file Substitute for the DOM KeyboardEvent Class.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ */
+import { UIEventInit, UIEventService } from './UIEventService';
+/**
+ * The options for creating a keyboard event, on top of the ones every UI event has.
+ * @typedef {Object} KeyboardEventInit
+ * @property {string} [key=''] The value of the key, such as a or Enter
+ * @property {string} [code=''] The physical key, such as KeyA or Enter
+ * @property {number} [location=0] Where on the keyboard the key is (0 standard, 1 left, 2 right, 3 numeric pad)
+ * @property {boolean} [repeat=false] The key is being held down
+ * @property {boolean} [isComposing=false]
+ * @property {boolean} [ctrlKey=false]
+ * @property {boolean} [shiftKey=false]
+ * @property {boolean} [altKey=false]
+ * @property {boolean} [metaKey=false]
+ */
+export type KeyboardEventInit = UIEventInit & {
+    key?: string;
+    code?: string;
+    location?: number;
+    repeat?: boolean;
+    isComposing?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+};
+/**
+ * Simulate the behaviour of the KeyboardEvent Class when there is no DOM available.
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @class
+ * @augments UIEventService
+ * @property {string} key
+ * @property {string} code
+ * @property {number} location
+ * @property {boolean} repeat
+ * @property {boolean} isComposing
+ */
+export declare class KeyboardEventService extends UIEventService {
+    private readonly keyValue;
+    private readonly keyCode;
+    private readonly keyLocation;
+    private readonly held;
+    private readonly composing;
+    private readonly modifiers;
+    /**
+     * @param {string} [typeArg=''] The type of the event
+     * @param {KeyboardEventInit} [init={}] The options for the event
+     * @constructor
+     */
+    constructor(typeArg?: string, init?: KeyboardEventInit);
+    get key(): string;
+    get code(): string;
+    get location(): number;
+    get repeat(): boolean;
+    get isComposing(): boolean;
+    get ctrlKey(): boolean;
+    get shiftKey(): boolean;
+    get altKey(): boolean;
+    get metaKey(): boolean;
+    /**
+     * Whether a modifier key was held down when the event happened.
+     * @param {string} key Control, Shift, Alt or Meta
+     * @returns {boolean}
+     */
+    getModifierState(key: string): boolean;
+}