@depup/testing-library__user-event 14.6.3-depup.0

package/dist/esm/event/dispatchEvent.js

@@ -0,0 +1,50 @@
+import './behavior/click.js';
+import './behavior/cut.js';
+import './behavior/keydown.js';
+import './behavior/keypress.js';
+import './behavior/keyup.js';
+import './behavior/paste.js';
+import { behavior } from './behavior/registry.js';
+import { wrapEvent } from './wrapEvent.js';
+import { isMouseEvent, isKeyboardEvent } from './eventMap.js';
+import { createEvent } from './createEvent.js';
+
+function dispatchUIEvent(target, type, init, preventDefault = false) {
+    if (isMouseEvent(type) || isKeyboardEvent(type)) {
+        init = {
+            ...init,
+            ...this.system.getUIEventModifiers()
+        };
+    }
+    const event = createEvent(type, target, init);
+    return dispatchEvent.call(this, target, event, preventDefault);
+}
+function dispatchEvent(target, event, preventDefault = false) {
+    var _behavior_type;
+    const type = event.type;
+    const behaviorImplementation = preventDefault ? ()=>{} : (_behavior_type = behavior[type]) === null || _behavior_type === void 0 ? void 0 : _behavior_type.call(behavior, event, target, this);
+    if (behaviorImplementation) {
+        event.preventDefault();
+        let defaultPrevented = false;
+        Object.defineProperty(event, 'defaultPrevented', {
+            get: ()=>defaultPrevented
+        });
+        Object.defineProperty(event, 'preventDefault', {
+            value: ()=>{
+                defaultPrevented = event.cancelable;
+            }
+        });
+        wrapEvent(()=>target.dispatchEvent(event));
+        if (!defaultPrevented) {
+            behaviorImplementation();
+        }
+        return !defaultPrevented;
+    }
+    return wrapEvent(()=>target.dispatchEvent(event));
+}
+function dispatchDOMEvent(target, type, init) {
+    const event = createEvent(type, target, init);
+    wrapEvent(()=>target.dispatchEvent(event));
+}
+
+export { dispatchDOMEvent, dispatchEvent, dispatchUIEvent };

package/dist/esm/event/eventMap.js

@@ -0,0 +1,277 @@
+const eventMap = {
+    auxclick: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    beforeinput: {
+        EventType: 'InputEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    blur: {
+        EventType: 'FocusEvent',
+        defaultInit: {
+            bubbles: false,
+            cancelable: false,
+            composed: true
+        }
+    },
+    click: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    contextmenu: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    copy: {
+        EventType: 'ClipboardEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    change: {
+        EventType: 'Event',
+        defaultInit: {
+            bubbles: true,
+            cancelable: false
+        }
+    },
+    cut: {
+        EventType: 'ClipboardEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    dblclick: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    focus: {
+        EventType: 'FocusEvent',
+        defaultInit: {
+            bubbles: false,
+            cancelable: false,
+            composed: true
+        }
+    },
+    focusin: {
+        EventType: 'FocusEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: false,
+            composed: true
+        }
+    },
+    focusout: {
+        EventType: 'FocusEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: false,
+            composed: true
+        }
+    },
+    keydown: {
+        EventType: 'KeyboardEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    keypress: {
+        EventType: 'KeyboardEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    keyup: {
+        EventType: 'KeyboardEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    paste: {
+        EventType: 'ClipboardEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    input: {
+        EventType: 'InputEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: false,
+            composed: true
+        }
+    },
+    mousedown: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    mouseenter: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: false,
+            cancelable: false,
+            composed: true
+        }
+    },
+    mouseleave: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: false,
+            cancelable: false,
+            composed: true
+        }
+    },
+    mousemove: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    mouseout: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    mouseover: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    mouseup: {
+        EventType: 'MouseEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    pointerover: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    pointerenter: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: false,
+            cancelable: false
+        }
+    },
+    pointerdown: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    pointermove: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    pointerup: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    pointercancel: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: false,
+            composed: true
+        }
+    },
+    pointerout: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true,
+            composed: true
+        }
+    },
+    pointerleave: {
+        EventType: 'PointerEvent',
+        defaultInit: {
+            bubbles: false,
+            cancelable: false
+        }
+    },
+    submit: {
+        EventType: 'Event',
+        defaultInit: {
+            bubbles: true,
+            cancelable: true
+        }
+    }
+};
+function getEventClass(type) {
+    return eventMap[type].EventType;
+}
+const mouseEvents = [
+    'MouseEvent',
+    'PointerEvent'
+];
+function isMouseEvent(type) {
+    return mouseEvents.includes(getEventClass(type));
+}
+function isKeyboardEvent(type) {
+    return getEventClass(type) === 'KeyboardEvent';
+}
+
+export { eventMap, isKeyboardEvent, isMouseEvent };

package/dist/esm/event/focus.js

@@ -0,0 +1,31 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { getActiveElement } from '../utils/focus/getActiveElement.js';
+import { isFocusable } from '../utils/focus/isFocusable.js';
+import { findClosest } from '../utils/misc/findClosest.js';
+import { updateSelectionOnFocus } from './selection/updateSelectionOnFocus.js';
+import { wrapEvent } from './wrapEvent.js';
+
+// Browsers do not dispatch FocusEvent if the document does not have focus.
+// TODO: simulate FocusEvent in browsers
+/**
+ * Focus closest focusable element.
+ */ function focusElement(element) {
+    const target = findClosest(element, isFocusable);
+    const activeElement = getActiveElement(element.ownerDocument);
+    if ((target !== null && target !== void 0 ? target : element.ownerDocument.body) === activeElement) {
+        return;
+    } else if (target) {
+        wrapEvent(()=>target.focus());
+    } else {
+        wrapEvent(()=>activeElement === null || activeElement === void 0 ? void 0 : activeElement.blur());
+    }
+    updateSelectionOnFocus(target !== null && target !== void 0 ? target : element.ownerDocument.body);
+}
+function blurElement(element) {
+    if (!isFocusable(element)) return;
+    const wasActive = getActiveElement(element.ownerDocument) === element;
+    if (!wasActive) return;
+    wrapEvent(()=>element.blur());
+}
+
+export { blurElement, focusElement };

package/dist/esm/event/index.js

@@ -0,0 +1,7 @@
+export { dispatchDOMEvent, dispatchEvent, dispatchUIEvent } from './dispatchEvent.js';
+export { blurElement, focusElement } from './focus.js';
+export { input } from './input.js';
+import '../utils/dataTransfer/Clipboard.js';
+export { setSelectionPerMouseDown } from './selection/setSelectionPerMouse.js';
+export { modifySelectionPerMouseMove } from './selection/modifySelectionPerMouse.js';
+export { isAllSelected, selectAll } from './selection/selectAll.js';

package/dist/esm/event/input.js

@@ -0,0 +1,156 @@
+import { setUIValue, clearInitialValue, getUIValue } from '../document/UI.js';
+import { isElementType } from '../utils/misc/isElementType.js';
+import '../utils/dataTransfer/Clipboard.js';
+import { isValidDateOrTimeValue, buildTimeValue } from '../utils/edit/timeValue.js';
+import { supportsMaxLength, getMaxLength } from '../utils/edit/maxLength.js';
+import { getNextCursorPosition } from '../utils/focus/cursor.js';
+import { commitValueAfterInput } from '../document/trackValue.js';
+import { getInputRange } from './selection/getInputRange.js';
+import { setSelection } from './selection/setSelection.js';
+
+function isDateOrTime(element) {
+    return isElementType(element, 'input') && [
+        'date',
+        'time'
+    ].includes(element.type);
+}
+function input(instance, element, data, inputType = 'insertText') {
+    const inputRange = getInputRange(element);
+    /* istanbul ignore if */ if (!inputRange) {
+        return;
+    }
+    // There is no `beforeinput` event on `date` and `time` input
+    if (!isDateOrTime(element)) {
+        const unprevented = instance.dispatchUIEvent(element, 'beforeinput', {
+            inputType,
+            data
+        });
+        if (!unprevented) {
+            return;
+        }
+    }
+    if ('startContainer' in inputRange) {
+        editContenteditable(instance, element, inputRange, data, inputType);
+    } else {
+        editInputElement(instance, element, inputRange, data, inputType);
+    }
+}
+function editContenteditable(instance, element, inputRange, data, inputType) {
+    let del = false;
+    if (!inputRange.collapsed) {
+        del = true;
+        inputRange.deleteContents();
+    } else if ([
+        'deleteContentBackward',
+        'deleteContentForward'
+    ].includes(inputType)) {
+        const nextPosition = getNextCursorPosition(inputRange.startContainer, inputRange.startOffset, inputType === 'deleteContentBackward' ? -1 : 1, inputType);
+        if (nextPosition) {
+            del = true;
+            const delRange = inputRange.cloneRange();
+            if (delRange.comparePoint(nextPosition.node, nextPosition.offset) < 0) {
+                delRange.setStart(nextPosition.node, nextPosition.offset);
+            } else {
+                delRange.setEnd(nextPosition.node, nextPosition.offset);
+            }
+            delRange.deleteContents();
+        }
+    }
+    if (data) {
+        if (inputRange.endContainer.nodeType === 3) {
+            const offset = inputRange.endOffset;
+            inputRange.endContainer.insertData(offset, data);
+            inputRange.setStart(inputRange.endContainer, offset + data.length);
+            inputRange.setEnd(inputRange.endContainer, offset + data.length);
+        } else {
+            const text = element.ownerDocument.createTextNode(data);
+            inputRange.insertNode(text);
+            inputRange.setStart(text, data.length);
+            inputRange.setEnd(text, data.length);
+        }
+    }
+    if (del || data) {
+        instance.dispatchUIEvent(element, 'input', {
+            inputType
+        });
+    }
+}
+function editInputElement(instance, element, inputRange, data, inputType) {
+    let dataToInsert = data;
+    if (supportsMaxLength(element)) {
+        const maxLength = getMaxLength(element);
+        if (maxLength !== undefined && data.length > 0) {
+            const selectionLength = inputRange.endOffset - inputRange.startOffset;
+            const spaceUntilMaxLength = maxLength - element.value.length + selectionLength;
+            if (spaceUntilMaxLength > 0) {
+                dataToInsert = data.substring(0, spaceUntilMaxLength);
+            } else {
+                return;
+            }
+        }
+    }
+    const { newValue, newOffset, oldValue } = calculateNewValue(dataToInsert, element, inputRange, inputType);
+    if (newValue === oldValue && newOffset === inputRange.startOffset && newOffset === inputRange.endOffset) {
+        return;
+    }
+    if (isElementType(element, 'input', {
+        type: 'number'
+    }) && !isValidNumberInput(newValue)) {
+        return;
+    }
+    setUIValue(element, newValue);
+    setSelection({
+        focusNode: element,
+        anchorOffset: newOffset,
+        focusOffset: newOffset
+    });
+    if (isDateOrTime(element)) {
+        if (isValidDateOrTimeValue(element, newValue)) {
+            commitInput(instance, element, newOffset, {});
+            instance.dispatchUIEvent(element, 'change');
+            clearInitialValue(element);
+        }
+    } else {
+        commitInput(instance, element, newOffset, {
+            data,
+            inputType
+        });
+    }
+}
+function calculateNewValue(inputData, node, { startOffset, endOffset }, inputType) {
+    const value = getUIValue(node);
+    const prologEnd = Math.max(0, startOffset === endOffset && inputType === 'deleteContentBackward' ? startOffset - 1 : startOffset);
+    const prolog = value.substring(0, prologEnd);
+    const epilogStart = Math.min(value.length, startOffset === endOffset && inputType === 'deleteContentForward' ? startOffset + 1 : endOffset);
+    const epilog = value.substring(epilogStart, value.length);
+    let newValue = `${prolog}${inputData}${epilog}`;
+    let newOffset = prologEnd + inputData.length;
+    if (isElementType(node, 'input', {
+        type: 'time'
+    })) {
+        const builtValue = buildTimeValue(newValue);
+        if (builtValue !== '' && isValidDateOrTimeValue(node, builtValue)) {
+            newValue = builtValue;
+            newOffset = builtValue.length;
+        }
+    }
+    return {
+        oldValue: value,
+        newValue,
+        newOffset
+    };
+}
+function commitInput(instance, element, newOffset, inputInit) {
+    instance.dispatchUIEvent(element, 'input', inputInit);
+    commitValueAfterInput(element, newOffset);
+}
+function isValidNumberInput(value) {
+    var _value_match, _value_match1;
+    // the browser allows some invalid input but not others
+    // it allows up to two '-' at any place before any 'e' or one directly following 'e'
+    // it allows one '.' at any place before e
+    const valueParts = value.split('e', 2);
+    return !(/[^\d.\-e]/.test(value) || Number((_value_match = value.match(/-/g)) === null || _value_match === void 0 ? void 0 : _value_match.length) > 2 || Number((_value_match1 = value.match(/\./g)) === null || _value_match1 === void 0 ? void 0 : _value_match1.length) > 1 || valueParts[1] && !/^-?\d*$/.test(valueParts[1]));
+}
+
+export { input };

package/dist/esm/event/radio.js

@@ -0,0 +1,25 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { isDisabled } from '../utils/misc/isDisabled.js';
+import { getWindow } from '../utils/misc/getWindow.js';
+import { focusElement } from './focus.js';
+
+function walkRadio(instance, el, direction) {
+    const window = getWindow(el);
+    const group = Array.from(el.ownerDocument.querySelectorAll(el.name ? `input[type="radio"][name="${window.CSS.escape(el.name)}"]` : `input[type="radio"][name=""], input[type="radio"]:not([name])`));
+    for(let i = group.findIndex((e)=>e === el) + direction;; i += direction){
+        if (!group[i]) {
+            i = direction > 0 ? 0 : group.length - 1;
+        }
+        if (group[i] === el) {
+            return;
+        }
+        if (isDisabled(group[i])) {
+            continue;
+        }
+        focusElement(group[i]);
+        instance.dispatchUIEvent(group[i], 'click');
+        return;
+    }
+}
+
+export { walkRadio };

package/dist/esm/event/selection/getInputRange.js

@@ -0,0 +1,16 @@
+import { getTargetTypeAndSelection } from './getTargetTypeAndSelection.js';
+
+/**
+ * Get the range that would be overwritten by input.
+ */ function getInputRange(focusNode) {
+    const typeAndSelection = getTargetTypeAndSelection(focusNode);
+    if (typeAndSelection.type === 'input') {
+        return typeAndSelection.selection;
+    } else if (typeAndSelection.type === 'contenteditable') {
+        var _typeAndSelection_selection;
+        // Multi-range on contenteditable edits the first selection instead of the last
+        return (_typeAndSelection_selection = typeAndSelection.selection) === null || _typeAndSelection_selection === void 0 ? void 0 : _typeAndSelection_selection.getRangeAt(0);
+    }
+}
+
+export { getInputRange };

package/dist/esm/event/selection/getTargetTypeAndSelection.js

@@ -0,0 +1,29 @@
+import { getUISelection } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { getContentEditable } from '../../utils/edit/isContentEditable.js';
+import { hasOwnSelection } from '../../utils/focus/selection.js';
+
+/**
+ * Determine which selection logic and selection ranges to consider.
+ */ function getTargetTypeAndSelection(node) {
+    const element = getElement(node);
+    if (element && hasOwnSelection(element)) {
+        return {
+            type: 'input',
+            selection: getUISelection(element)
+        };
+    }
+    const selection = element === null || element === void 0 ? void 0 : element.ownerDocument.getSelection();
+    // It is possible to extend a single-range selection into a contenteditable.
+    // This results in the range acting like a range outside of contenteditable.
+    const isCE = getContentEditable(node) && (selection === null || selection === void 0 ? void 0 : selection.anchorNode) && getContentEditable(selection.anchorNode);
+    return {
+        type: isCE ? 'contenteditable' : 'default',
+        selection
+    };
+}
+function getElement(node) {
+    return node.nodeType === 1 ? node : node.parentElement;
+}
+
+export { getTargetTypeAndSelection };

package/dist/esm/event/selection/index.js

@@ -0,0 +1,9 @@
+export { getInputRange } from './getInputRange.js';
+export { modifySelection } from './modifySelection.js';
+export { moveSelection } from './moveSelection.js';
+export { setSelectionPerMouseDown } from './setSelectionPerMouse.js';
+export { modifySelectionPerMouseMove } from './modifySelectionPerMouse.js';
+export { isAllSelected, selectAll } from './selectAll.js';
+export { setSelectionRange } from './setSelectionRange.js';
+export { setSelection } from './setSelection.js';
+export { updateSelectionOnFocus } from './updateSelectionOnFocus.js';

package/dist/esm/event/selection/modifySelection.js

@@ -0,0 +1,19 @@
+import { setUISelection } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { getTargetTypeAndSelection } from './getTargetTypeAndSelection.js';
+
+/**
+ * Extend/shrink the selection like with Shift+Arrows or Shift+Mouse
+ */ function modifySelection({ focusNode, focusOffset }) {
+    var _focusNode_ownerDocument_getSelection, _focusNode_ownerDocument;
+    const typeAndSelection = getTargetTypeAndSelection(focusNode);
+    if (typeAndSelection.type === 'input') {
+        return setUISelection(focusNode, {
+            anchorOffset: typeAndSelection.selection.anchorOffset,
+            focusOffset
+        }, 'modify');
+    }
+    (_focusNode_ownerDocument = focusNode.ownerDocument) === null || _focusNode_ownerDocument === void 0 ? void 0 : (_focusNode_ownerDocument_getSelection = _focusNode_ownerDocument.getSelection()) === null || _focusNode_ownerDocument_getSelection === void 0 ? void 0 : _focusNode_ownerDocument_getSelection.extend(focusNode, focusOffset);
+}
+
+export { modifySelection };

package/dist/esm/event/selection/modifySelectionPerMouse.js

@@ -0,0 +1,38 @@
+import { setUISelection } from '../../document/UI.js';
+import '../../utils/dataTransfer/Clipboard.js';
+import { resolveCaretPosition } from './resolveCaretPosition.js';
+
+function modifySelectionPerMouseMove(selectionRange, { document, target, node, offset }) {
+    const selectionFocus = resolveCaretPosition({
+        target,
+        node,
+        offset
+    });
+    if ('node' in selectionRange) {
+        // When the mouse is dragged outside of an input/textarea,
+        // the selection is extended to the beginning or end of the input
+        // depending on pointer position.
+        // TODO: extend selection according to pointer position
+        /* istanbul ignore else */ if (selectionFocus.node === selectionRange.node) {
+            const anchorOffset = selectionFocus.offset < selectionRange.start ? selectionRange.end : selectionRange.start;
+            const focusOffset = selectionFocus.offset > selectionRange.end || selectionFocus.offset < selectionRange.start ? selectionFocus.offset : selectionRange.end;
+            setUISelection(selectionRange.node, {
+                anchorOffset,
+                focusOffset
+            });
+        }
+    } else {
+        const range = selectionRange.cloneRange();
+        const cmp = range.comparePoint(selectionFocus.node, selectionFocus.offset);
+        if (cmp < 0) {
+            range.setStart(selectionFocus.node, selectionFocus.offset);
+        } else if (cmp > 0) {
+            range.setEnd(selectionFocus.node, selectionFocus.offset);
+        }
+        const selection = document.getSelection();
+        selection === null || selection === void 0 ? void 0 : selection.removeAllRanges();
+        selection === null || selection === void 0 ? void 0 : selection.addRange(range.cloneRange());
+    }
+}
+
+export { modifySelectionPerMouseMove };