main - 207bc6c build: clean-up to use fine-grained targets for faster rebuilds

Author: devversion

fesm2022/test-element-errors-83375db9.mjs

@@ -1,4 +1,3 @@
-export { C as ComponentHarness, a as ContentContainerComponentHarness, b as HarnessEnvironment, H as HarnessPredicate, T as TestKey, _ as _getTextWithExcludedElements, h as handleAutoChangeDetectionStatus, m as manualChangeDetection, p as parallel, s as stopHandlingAutoChangeDetectionStatus } from './text-filtering-e9a6b8d9.mjs';
-export { g as getNoKeysSpecifiedError } from './test-element-errors-83375db9.mjs';
+export { C as ComponentHarness, a as ContentContainerComponentHarness, b as HarnessEnvironment, H as HarnessPredicate, T as TestKey, _ as _getTextWithExcludedElements, g as getNoKeysSpecifiedError, h as handleAutoChangeDetectionStatus, m as manualChangeDetection, p as parallel, s as stopHandlingAutoChangeDetectionStatus } from './text-filtering-55cbd0d9.mjs';
 import 'rxjs';
 //# sourceMappingURL=testing.mjs.map

fesm2022/test-element-errors-83375db9.mjs.map

@@ -1,6 +1,5 @@
 import * as webdriver from 'selenium-webdriver';
-import { g as getNoKeysSpecifiedError } from '../test-element-errors-83375db9.mjs';
-import { T as TestKey, _ as _getTextWithExcludedElements, b as HarnessEnvironment } from '../text-filtering-e9a6b8d9.mjs';
+import { T as TestKey, g as getNoKeysSpecifiedError, _ as _getTextWithExcludedElements, b as HarnessEnvironment } from '../text-filtering-55cbd0d9.mjs';
 import 'rxjs';
 
 /**

fesm2022/testing.mjs

@@ -1,10 +1,8 @@
 import { flush } from '@angular/core/testing';
 import { takeWhile } from 'rxjs/operators';
 import { BehaviorSubject } from 'rxjs';
-import { l as triggerBlur, m as isTextInput, o as clearElement, t as triggerFocus, c as dispatchMouseEvent, n as typeInElement, a as dispatchFakeEvent, k as createFakeEvent, d as dispatchEvent, e as dispatchPointerEvent } from '../type-in-element-de7fd3bb.mjs';
-import { _ as _getTextWithExcludedElements, T as TestKey, b as HarnessEnvironment, h as handleAutoChangeDetectionStatus, s as stopHandlingAutoChangeDetectionStatus } from '../text-filtering-e9a6b8d9.mjs';
-import { B as BACKSPACE, T as TAB, h as ENTER, S as SHIFT, C as CONTROL, A as ALT, e as ESCAPE, b as PAGE_UP, P as PAGE_DOWN, E as END, H as HOME, L as LEFT_ARROW, U as UP_ARROW, R as RIGHT_ARROW, D as DOWN_ARROW, I as INSERT, n as DELETE, au as F1, av as F2, aw as F3, ax as F4, ay as F5, az as F6, aA as F7, aB as F8, aC as F9, aD as F10, aE as F11, aF as F12, a as META, aT as COMMA } from '../keycodes-0e4398c6.mjs';
-import '../test-element-errors-83375db9.mjs';
+import { g as getNoKeysSpecifiedError, _ as _getTextWithExcludedElements, T as TestKey, b as HarnessEnvironment, h as handleAutoChangeDetectionStatus, s as stopHandlingAutoChangeDetectionStatus } from '../text-filtering-55cbd0d9.mjs';
+import { aV as PERIOD, B as BACKSPACE, T as TAB, h as ENTER, S as SHIFT, C as CONTROL, A as ALT, e as ESCAPE, b as PAGE_UP, P as PAGE_DOWN, E as END, H as HOME, L as LEFT_ARROW, U as UP_ARROW, R as RIGHT_ARROW, D as DOWN_ARROW, I as INSERT, n as DELETE, au as F1, av as F2, aw as F3, ax as F4, ay as F5, az as F6, aA as F7, aB as F8, aC as F9, aD as F10, aE as F11, aF as F12, a as META, aT as COMMA } from '../keycodes-0e4398c6.mjs';
 
 /** Unique symbol that is used to patch a property to a proxy zone. */
 const stateObservableSymbol = Symbol('ProxyZone_PATCHED#stateObservable');
@@ -81,6 +79,293 @@ class TaskStateZoneInterceptor {
     }
 }
 
+/** Used to generate unique IDs for events. */
+/**
+ * Creates a browser MouseEvent with the specified options.
+ * @docs-private
+ */
+function createMouseEvent(type, clientX = 0, clientY = 0, offsetX = 0, offsetY = 0, button = 0, modifiers = {}) {
+    // Note: We cannot determine the position of the mouse event based on the screen
+    // because the dimensions and position of the browser window are not available
+    // To provide reasonable `screenX` and `screenY` coordinates, we simply use the
+    // client coordinates as if the browser is opened in fullscreen.
+    const screenX = clientX;
+    const screenY = clientY;
+    const event = new MouseEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        composed: true, // Required for shadow DOM events.
+        view: window,
+        detail: 1,
+        relatedTarget: null,
+        screenX,
+        screenY,
+        clientX,
+        clientY,
+        ctrlKey: modifiers.control,
+        altKey: modifiers.alt,
+        shiftKey: modifiers.shift,
+        metaKey: modifiers.meta,
+        button: button,
+        buttons: 1,
+    });
+    // The `MouseEvent` constructor doesn't allow us to pass these properties into the constructor.
+    // Override them to `1`, because they're used for fake screen reader event detection.
+    if (offsetX != null) {
+        defineReadonlyEventProperty(event, 'offsetX', offsetX);
+    }
+    if (offsetY != null) {
+        defineReadonlyEventProperty(event, 'offsetY', offsetY);
+    }
+    return event;
+}
+/**
+ * Creates a browser `PointerEvent` with the specified options. Pointer events
+ * by default will appear as if they are the primary pointer of their type.
+ * https://www.w3.org/TR/pointerevents2/#dom-pointerevent-isprimary.
+ *
+ * For example, if pointer events for a multi-touch interaction are created, the non-primary
+ * pointer touches would need to be represented by non-primary pointer events.
+ *
+ * @docs-private
+ */
+function createPointerEvent(type, clientX = 0, clientY = 0, offsetX, offsetY, options = { isPrimary: true }) {
+    const event = new PointerEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        composed: true, // Required for shadow DOM events.
+        view: window,
+        clientX,
+        clientY,
+        ...options,
+    });
+    if (offsetX != null) {
+        defineReadonlyEventProperty(event, 'offsetX', offsetX);
+    }
+    if (offsetY != null) {
+        defineReadonlyEventProperty(event, 'offsetY', offsetY);
+    }
+    return event;
+}
+/**
+ * Creates a keyboard event with the specified key and modifiers.
+ * @docs-private
+ */
+function createKeyboardEvent(type, keyCode = 0, key = '', modifiers = {}, code = '') {
+    return new KeyboardEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        composed: true, // Required for shadow DOM events.
+        view: window,
+        keyCode,
+        key,
+        shiftKey: modifiers.shift,
+        metaKey: modifiers.meta,
+        altKey: modifiers.alt,
+        ctrlKey: modifiers.control,
+        code,
+    });
+}
+/**
+ * Creates a fake event object with any desired event type.
+ * @docs-private
+ */
+function createFakeEvent(type, bubbles = false, cancelable = true, composed = true) {
+    return new Event(type, { bubbles, cancelable, composed });
+}
+/**
+ * Defines a readonly property on the given event object. Readonly properties on an event object
+ * are always set as configurable as that matches default readonly properties for DOM event objects.
+ */
+function defineReadonlyEventProperty(event, propertyName, value) {
+    Object.defineProperty(event, propertyName, { get: () => value, configurable: true });
+}
+
+/**
+ * Utility to dispatch any event on a Node.
+ * @docs-private
+ */
+function dispatchEvent(node, event) {
+    node.dispatchEvent(event);
+    return event;
+}
+/**
+ * Shorthand to dispatch a fake event on a specified node.
+ * @docs-private
+ */
+function dispatchFakeEvent(node, type, bubbles) {
+    return dispatchEvent(node, createFakeEvent(type, bubbles));
+}
+/**
+ * Shorthand to dispatch a keyboard event with a specified key code and
+ * optional modifiers.
+ * @docs-private
+ */
+function dispatchKeyboardEvent(node, type, keyCode, key, modifiers, code) {
+    return dispatchEvent(node, createKeyboardEvent(type, keyCode, key, modifiers, code));
+}
+/**
+ * Shorthand to dispatch a mouse event on the specified coordinates.
+ * @docs-private
+ */
+function dispatchMouseEvent(node, type, clientX = 0, clientY = 0, offsetX, offsetY, button, modifiers) {
+    return dispatchEvent(node, createMouseEvent(type, clientX, clientY, offsetX, offsetY, button, modifiers));
+}
+/**
+ * Shorthand to dispatch a pointer event on the specified coordinates.
+ * @docs-private
+ */
+function dispatchPointerEvent(node, type, clientX = 0, clientY = 0, offsetX, offsetY, options) {
+    return dispatchEvent(node, createPointerEvent(type, clientX, clientY, offsetX, offsetY, options));
+}
+
+function triggerFocusChange(element, event) {
+    let eventFired = false;
+    const handler = () => (eventFired = true);
+    element.addEventListener(event, handler);
+    element[event]();
+    element.removeEventListener(event, handler);
+    if (!eventFired) {
+        dispatchFakeEvent(element, event);
+    }
+}
+/** @docs-private */
+function triggerFocus(element) {
+    triggerFocusChange(element, 'focus');
+}
+/** @docs-private */
+function triggerBlur(element) {
+    triggerFocusChange(element, 'blur');
+}
+
+/** Input types for which the value can be entered incrementally. */
+const incrementalInputTypes = new Set([
+    'text',
+    'email',
+    'hidden',
+    'password',
+    'search',
+    'tel',
+    'url',
+]);
+/**
+ * Manual mapping of some common characters to their `code` in a keyboard event. Non-exhaustive, see
+ * the tables on MDN for more info: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/keyCode
+ */
+const charsToCodes = {
+    ' ': 'Space',
+    '.': 'Period',
+    ',': 'Comma',
+    '`': 'Backquote',
+    '-': 'Minus',
+    '=': 'Equal',
+    '[': 'BracketLeft',
+    ']': 'BracketRight',
+    '\\': 'Backslash',
+    '/': 'Slash',
+    "'": 'Quote',
+    '"': 'Quote',
+    ';': 'Semicolon',
+};
+/**
+ * Determines the `KeyboardEvent.key` from a character. See #27034 and
+ * https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code
+ */
+function getKeyboardEventCode(char) {
+    if (char.length !== 1) {
+        return '';
+    }
+    const charCode = char.charCodeAt(0);
+    // Key is a letter between a and z, uppercase or lowercase.
+    if ((charCode >= 97 && charCode <= 122) || (charCode >= 65 && charCode <= 90)) {
+        return `Key${char.toUpperCase()}`;
+    }
+    // Digits from 0 to 9.
+    if (48 <= charCode && charCode <= 57) {
+        return `Digit${char}`;
+    }
+    return charsToCodes[char] ?? '';
+}
+/**
+ * Checks whether the given Element is a text input element.
+ * @docs-private
+ */
+function isTextInput(element) {
+    const nodeName = element.nodeName.toLowerCase();
+    return nodeName === 'input' || nodeName === 'textarea';
+}
+function typeInElement(element, ...modifiersAndKeys) {
+    const first = modifiersAndKeys[0];
+    let modifiers;
+    let rest;
+    if (first !== undefined &&
+        typeof first !== 'string' &&
+        first.keyCode === undefined &&
+        first.key === undefined) {
+        modifiers = first;
+        rest = modifiersAndKeys.slice(1);
+    }
+    else {
+        modifiers = {};
+        rest = modifiersAndKeys;
+    }
+    const isInput = isTextInput(element);
+    const inputType = element.getAttribute('type') || 'text';
+    const keys = rest
+        .map(k => typeof k === 'string'
+        ? k.split('').map(c => ({
+            keyCode: c.toUpperCase().charCodeAt(0),
+            key: c,
+            code: getKeyboardEventCode(c),
+        }))
+        : [k])
+        .reduce((arr, k) => arr.concat(k), []);
+    // Throw an error if no keys have been specified. Calling this function with no
+    // keys should not result in a focus event being dispatched unexpectedly.
+    if (keys.length === 0) {
+        throw getNoKeysSpecifiedError();
+    }
+    // We simulate the user typing in a value by incrementally assigning the value below. The problem
+    // is that for some input types, the browser won't allow for an invalid value to be set via the
+    // `value` property which will always be the case when going character-by-character. If we detect
+    // such an input, we have to set the value all at once or listeners to the `input` event (e.g.
+    // the `ReactiveFormsModule` uses such an approach) won't receive the correct value.
+    const enterValueIncrementally = inputType === 'number'
+        ? // The value can be set character by character in number inputs if it doesn't have any decimals.
+            keys.every(key => key.key !== '.' && key.key !== '-' && key.keyCode !== PERIOD)
+        : incrementalInputTypes.has(inputType);
+    triggerFocus(element);
+    // When we aren't entering the value incrementally, assign it all at once ahead
+    // of time so that any listeners to the key events below will have access to it.
+    if (!enterValueIncrementally) {
+        element.value = keys.reduce((value, key) => value + (key.key || ''), '');
+    }
+    for (const key of keys) {
+        dispatchKeyboardEvent(element, 'keydown', key.keyCode, key.key, modifiers, key.code);
+        dispatchKeyboardEvent(element, 'keypress', key.keyCode, key.key, modifiers, key.code);
+        if (isInput && key.key && key.key.length === 1) {
+            if (enterValueIncrementally) {
+                element.value += key.key;
+                dispatchFakeEvent(element, 'input');
+            }
+        }
+        dispatchKeyboardEvent(element, 'keyup', key.keyCode, key.key, modifiers, key.code);
+    }
+    // Since we weren't dispatching `input` events while sending the keys, we have to do it now.
+    if (!enterValueIncrementally) {
+        dispatchFakeEvent(element, 'input');
+    }
+}
+/**
+ * Clears the text in an input or textarea element.
+ * @docs-private
+ */
+function clearElement(element) {
+    triggerFocus(element);
+    element.value = '';
+    dispatchFakeEvent(element, 'input');
+}
+
 /** Maps `TestKey` constants to the `keyCode` and `key` values used by native browser events. */
 const keyMap = {
     [TestKey.BACKSPACE]: { keyCode: BACKSPACE, key: 'Backspace', code: 'Backspace' },