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

package/dist/cjs/event/selection/moveSelection.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var UI = require('../../document/UI.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var cursor = require('../../utils/focus/cursor.js');
+var selection = require('../../utils/focus/selection.js');
+var setSelection = require('./setSelection.js');
+
+/**
+ * Move the selection
+ */ function moveSelection(node, direction) {
+    // TODO: implement shift
+    if (selection.hasOwnSelection(node)) {
+        const selection = UI.getUISelection(node);
+        setSelection.setSelection({
+            focusNode: node,
+            focusOffset: selection.startOffset === selection.endOffset ? selection.focusOffset + direction : direction < 0 ? selection.startOffset : selection.endOffset
+        });
+    } else {
+        const selection = node.ownerDocument.getSelection();
+        if (!(selection === null || selection === void 0 ? void 0 : selection.focusNode)) {
+            return;
+        }
+        if (selection.isCollapsed) {
+            const nextPosition = cursor.getNextCursorPosition(selection.focusNode, selection.focusOffset, direction);
+            if (nextPosition) {
+                setSelection.setSelection({
+                    focusNode: nextPosition.node,
+                    focusOffset: nextPosition.offset
+                });
+            }
+        } else {
+            selection[direction < 0 ? 'collapseToStart' : 'collapseToEnd']();
+        }
+    }
+}
+
+exports.moveSelection = moveSelection;

package/dist/cjs/event/selection/resolveCaretPosition.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var UI = require('../../document/UI.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var selection = require('../../utils/focus/selection.js');
+
+function resolveCaretPosition({ target, node, offset }) {
+    if (selection.hasOwnSelection(target)) {
+        return {
+            node: target,
+            offset: offset !== null && offset !== void 0 ? offset : UI.getUIValue(target).length
+        };
+    } else if (node) {
+        return {
+            node,
+            offset: offset !== null && offset !== void 0 ? offset : node.nodeType === 3 ? node.nodeValue.length : node.childNodes.length
+        };
+    }
+    return findNodeAtTextOffset(target, offset);
+}
+function findNodeAtTextOffset(node, offset, isRoot = true) {
+    // When clicking after the content the browser behavior can be complicated:
+    // 1. If there is textContent after the last element child,
+    // the cursor is moved there.
+    // 2. If there is textContent in the last element child,
+    // the browser moves the cursor to the last non-empty text node inside this element.
+    // 3. Otherwise the cursor is moved to the end of the target.
+    let i = offset === undefined ? node.childNodes.length - 1 : 0;
+    const step = offset === undefined ? -1 : 1;
+    while(offset === undefined ? i >= (isRoot ? Math.max(node.childNodes.length - 1, 0) : 0) : i <= node.childNodes.length){
+        if (offset && i === node.childNodes.length) {
+            throw new Error('The given offset is out of bounds.');
+        }
+        const c = node.childNodes.item(i);
+        const text = String(c.textContent);
+        if (text.length) {
+            if (offset !== undefined && text.length < offset) {
+                offset -= text.length;
+            } else if (c.nodeType === 1) {
+                return findNodeAtTextOffset(c, offset, false);
+            } else {
+                // The pre-commit hooks keeps changing this
+                // See https://github.com/kentcdodds/kcd-scripts/issues/218
+                /* istanbul ignore else */ if (c.nodeType === 3) {
+                    return {
+                        node: c,
+                        offset: offset !== null && offset !== void 0 ? offset : c.nodeValue.length
+                    };
+                }
+            }
+        }
+        i += step;
+    }
+    return {
+        node,
+        offset: node.childNodes.length
+    };
+}
+
+exports.resolveCaretPosition = resolveCaretPosition;

package/dist/cjs/event/selection/selectAll.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var UI = require('../../document/UI.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../../utils/edit/isContentEditable.js');
+var selection = require('../../utils/focus/selection.js');
+var setSelection = require('./setSelection.js');
+
+/**
+ * Expand a selection like the browser does when pressing Ctrl+A.
+ */ function selectAll(target) {
+    var _getContentEditable;
+    if (selection.hasOwnSelection(target)) {
+        return setSelection.setSelection({
+            focusNode: target,
+            anchorOffset: 0,
+            focusOffset: UI.getUIValue(target).length
+        });
+    }
+    const focusNode = (_getContentEditable = isContentEditable.getContentEditable(target)) !== null && _getContentEditable !== void 0 ? _getContentEditable : target.ownerDocument.body;
+    setSelection.setSelection({
+        focusNode,
+        anchorOffset: 0,
+        focusOffset: focusNode.childNodes.length
+    });
+}
+function isAllSelected(target) {
+    var _getContentEditable;
+    if (selection.hasOwnSelection(target)) {
+        return UI.getUISelection(target).startOffset === 0 && UI.getUISelection(target).endOffset === UI.getUIValue(target).length;
+    }
+    const focusNode = (_getContentEditable = isContentEditable.getContentEditable(target)) !== null && _getContentEditable !== void 0 ? _getContentEditable : target.ownerDocument.body;
+    const selection$1 = target.ownerDocument.getSelection();
+    return (selection$1 === null || selection$1 === void 0 ? void 0 : selection$1.anchorNode) === focusNode && selection$1.focusNode === focusNode && selection$1.anchorOffset === 0 && selection$1.focusOffset === focusNode.childNodes.length;
+}
+
+exports.isAllSelected = isAllSelected;
+exports.selectAll = selectAll;

package/dist/cjs/event/selection/setSelection.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var UI = require('../../document/UI.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var getTargetTypeAndSelection = require('./getTargetTypeAndSelection.js');
+
+/**
+ * Set the selection
+ */ function setSelection({ focusNode, focusOffset, anchorNode = focusNode, anchorOffset = focusOffset }) {
+    var _anchorNode_ownerDocument_getSelection, _anchorNode_ownerDocument;
+    const typeAndSelection = getTargetTypeAndSelection.getTargetTypeAndSelection(focusNode);
+    if (typeAndSelection.type === 'input') {
+        return UI.setUISelection(focusNode, {
+            anchorOffset,
+            focusOffset
+        });
+    }
+    (_anchorNode_ownerDocument = anchorNode.ownerDocument) === null || _anchorNode_ownerDocument === void 0 ? void 0 : (_anchorNode_ownerDocument_getSelection = _anchorNode_ownerDocument.getSelection()) === null || _anchorNode_ownerDocument_getSelection === void 0 ? void 0 : _anchorNode_ownerDocument_getSelection.setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset);
+}
+
+exports.setSelection = setSelection;

package/dist/cjs/event/selection/setSelectionPerMouse.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var UI = require('../../document/UI.js');
+require('../../utils/dataTransfer/Clipboard.js');
+var selection = require('../../utils/focus/selection.js');
+var resolveCaretPosition = require('./resolveCaretPosition.js');
+
+function setSelectionPerMouseDown({ document, target, clickCount, node, offset }) {
+    if (selection.hasNoSelection(target)) {
+        return;
+    }
+    const targetHasOwnSelection = selection.hasOwnSelection(target);
+    // On non-input elements the text selection per multiple click
+    // can extend beyond the target boundaries.
+    // The exact mechanism what is considered in the same line is unclear.
+    // Looks it might be every inline element.
+    // TODO: Check what might be considered part of the same line of text.
+    const text = String(targetHasOwnSelection ? UI.getUIValue(target) : target.textContent);
+    const [start, end] = node ? [
+        offset,
+        offset
+    ] : getTextRange(text, offset, clickCount);
+    // TODO: implement modifying selection per shift/ctrl+mouse
+    if (targetHasOwnSelection) {
+        UI.setUISelection(target, {
+            anchorOffset: start !== null && start !== void 0 ? start : text.length,
+            focusOffset: end !== null && end !== void 0 ? end : text.length
+        });
+        return {
+            node: target,
+            start: start !== null && start !== void 0 ? start : 0,
+            end: end !== null && end !== void 0 ? end : text.length
+        };
+    } else {
+        const { node: startNode, offset: startOffset } = resolveCaretPosition.resolveCaretPosition({
+            target,
+            node,
+            offset: start
+        });
+        const { node: endNode, offset: endOffset } = resolveCaretPosition.resolveCaretPosition({
+            target,
+            node,
+            offset: end
+        });
+        const range = target.ownerDocument.createRange();
+        try {
+            range.setStart(startNode, startOffset);
+            range.setEnd(endNode, endOffset);
+        } catch  {
+            throw new Error('The given offset is out of bounds.');
+        }
+        const selection = document.getSelection();
+        selection === null || selection === void 0 ? void 0 : selection.removeAllRanges();
+        selection === null || selection === void 0 ? void 0 : selection.addRange(range.cloneRange());
+        return range;
+    }
+}
+function getTextRange(text, pos, clickCount) {
+    if (clickCount % 3 === 1 || text.length === 0) {
+        return [
+            pos,
+            pos
+        ];
+    }
+    const textPos = pos !== null && pos !== void 0 ? pos : text.length;
+    if (clickCount % 3 === 2) {
+        return [
+            textPos - text.substr(0, pos).match(/(\w+|\s+|\W)?$/)[0].length,
+            pos === undefined ? pos : pos + text.substr(pos).match(/^(\w+|\s+|\W)?/)[0].length
+        ];
+    }
+    // triple click
+    return [
+        textPos - text.substr(0, pos).match(/[^\r\n]*$/)[0].length,
+        pos === undefined ? pos : pos + text.substr(pos).match(/^[^\r\n]*/)[0].length
+    ];
+}
+
+exports.setSelectionPerMouseDown = setSelectionPerMouseDown;

package/dist/cjs/event/selection/setSelectionRange.js

@@ -0,0 +1,31 @@
+'use strict';
+
+require('../../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../../utils/edit/isContentEditable.js');
+var selection = require('../../utils/focus/selection.js');
+var setSelection = require('./setSelection.js');
+
+/**
+ * Backward-compatible selection.
+ *
+ * Handles input elements and contenteditable if it only contains a single text node.
+ */ function setSelectionRange(element, anchorOffset, focusOffset) {
+    var _element_firstChild;
+    if (selection.hasOwnSelection(element)) {
+        return setSelection.setSelection({
+            focusNode: element,
+            anchorOffset,
+            focusOffset
+        });
+    }
+    /* istanbul ignore else */ if (isContentEditable.isContentEditable(element) && ((_element_firstChild = element.firstChild) === null || _element_firstChild === void 0 ? void 0 : _element_firstChild.nodeType) === 3) {
+        return setSelection.setSelection({
+            focusNode: element.firstChild,
+            anchorOffset,
+            focusOffset
+        });
+    }
+    /* istanbul ignore next */ throw new Error('Not implemented. The result of this interaction is unreliable.');
+}
+
+exports.setSelectionRange = setSelectionRange;

package/dist/cjs/event/selection/updateSelectionOnFocus.js

@@ -0,0 +1,40 @@
+'use strict';
+
+require('../../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../../utils/edit/isContentEditable.js');
+var selection = require('../../utils/focus/selection.js');
+
+// The browser implementation seems to have changed.
+// When focus is inside <input type="text"/>,
+// Chrome updates Selection to be collapsed at the position of the input element.
+// TODO: update implementation to match that of current browsers
+/**
+ * Reset the Document Selection when moving focus into an element
+ * with own selection implementation.
+ */ function updateSelectionOnFocus(element) {
+    const selection$1 = element.ownerDocument.getSelection();
+    /* istanbul ignore if */ if (!(selection$1 === null || selection$1 === void 0 ? void 0 : selection$1.focusNode)) {
+        return;
+    }
+    // If the focus moves inside an element with own selection implementation,
+    // the document selection will be this element.
+    // But if the focused element is inside a contenteditable,
+    // 1) a collapsed selection will be retained.
+    // 2) other selections will be replaced by a cursor
+    //  2.a) at the start of the first child if it is a text node
+    //  2.b) at the start of the contenteditable.
+    if (selection.hasOwnSelection(element)) {
+        const contenteditable = isContentEditable.getContentEditable(selection$1.focusNode);
+        if (contenteditable) {
+            if (!selection$1.isCollapsed) {
+                var _contenteditable_firstChild;
+                const focusNode = ((_contenteditable_firstChild = contenteditable.firstChild) === null || _contenteditable_firstChild === void 0 ? void 0 : _contenteditable_firstChild.nodeType) === 3 ? contenteditable.firstChild : contenteditable;
+                selection$1.setBaseAndExtent(focusNode, 0, focusNode, 0);
+            }
+        } else {
+            selection$1.setBaseAndExtent(element, 0, element, 0);
+        }
+    }
+}
+
+exports.updateSelectionOnFocus = updateSelectionOnFocus;

package/dist/cjs/event/types.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/event/wrapEvent.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var dom = require('@testing-library/dom');
+
+function wrapEvent(cb, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+_element) {
+    return dom.getConfig().eventWrapper(cb);
+}
+
+exports.wrapEvent = wrapEvent;

package/dist/cjs/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./setup/index.js');
+var options = require('./options.js');
+
+
+
+exports.default = index.userEvent;
+exports.userEvent = index.userEvent;
+exports.PointerEventsCheckLevel = options.PointerEventsCheckLevel;

package/dist/cjs/keyboard/index.js

@@ -0,0 +1,40 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var wait = require('../utils/misc/wait.js');
+var parseKeyDef = require('./parseKeyDef.js');
+
+async function keyboard(text) {
+    const actions = parseKeyDef.parseKeyDef(this.config.keyboardMap, text);
+    for(let i = 0; i < actions.length; i++){
+        await wait.wait(this.config);
+        await keyboardAction(this, actions[i]);
+    }
+}
+async function keyboardAction(instance, { keyDef, releasePrevious, releaseSelf, repeat }) {
+    const { system } = instance;
+    // Release the key automatically if it was pressed before.
+    if (system.keyboard.isKeyPressed(keyDef)) {
+        await system.keyboard.keyup(instance, keyDef);
+    }
+    if (!releasePrevious) {
+        for(let i = 1; i <= repeat; i++){
+            await system.keyboard.keydown(instance, keyDef);
+            if (i < repeat) {
+                await wait.wait(instance.config);
+            }
+        }
+        // Release the key only on the last iteration on `state.repeatKey`.
+        if (releaseSelf) {
+            await system.keyboard.keyup(instance, keyDef);
+        }
+    }
+}
+async function releaseAllKeys(instance) {
+    for (const k of instance.system.keyboard.getPressedKeys()){
+        await instance.system.keyboard.keyup(instance, k);
+    }
+}
+
+exports.keyboard = keyboard;
+exports.releaseAllKeys = releaseAllKeys;

package/dist/cjs/keyboard/keyMap.js

@@ -0,0 +1,178 @@
+'use strict';
+
+var keyboard = require('../system/keyboard.js');
+
+/**
+ * Mapping for a default US-104-QWERTY keyboard
+ */ const defaultKeyMap = [
+    // alphanumeric block - writing system
+    ...'0123456789'.split('').map((c)=>({
+            code: `Digit${c}`,
+            key: c
+        })),
+    ...')!@#$%^&*('.split('').map((c, i)=>({
+            code: `Digit${i}`,
+            key: c,
+            shiftKey: true
+        })),
+    ...'abcdefghijklmnopqrstuvwxyz'.split('').map((c)=>({
+            code: `Key${c.toUpperCase()}`,
+            key: c
+        })),
+    ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map((c)=>({
+            code: `Key${c}`,
+            key: c,
+            shiftKey: true
+        })),
+    {
+        code: 'BracketLeft',
+        key: '['
+    },
+    {
+        code: 'BracketLeft',
+        key: '{',
+        shiftKey: true
+    },
+    {
+        code: 'BracketRight',
+        key: ']'
+    },
+    {
+        code: 'BracketRight',
+        key: '}',
+        shiftKey: true
+    },
+    // alphanumeric block - functional
+    {
+        code: 'Space',
+        key: ' '
+    },
+    {
+        code: 'AltLeft',
+        key: 'Alt',
+        location: keyboard.DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'AltRight',
+        key: 'Alt',
+        location: keyboard.DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ShiftLeft',
+        key: 'Shift',
+        location: keyboard.DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'ShiftRight',
+        key: 'Shift',
+        location: keyboard.DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ControlLeft',
+        key: 'Control',
+        location: keyboard.DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'ControlRight',
+        key: 'Control',
+        location: keyboard.DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'MetaLeft',
+        key: 'Meta',
+        location: keyboard.DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'MetaRight',
+        key: 'Meta',
+        location: keyboard.DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'OSLeft',
+        key: 'OS',
+        location: keyboard.DOM_KEY_LOCATION.LEFT
+    },
+    {
+        code: 'OSRight',
+        key: 'OS',
+        location: keyboard.DOM_KEY_LOCATION.RIGHT
+    },
+    {
+        code: 'ContextMenu',
+        key: 'ContextMenu'
+    },
+    {
+        code: 'Tab',
+        key: 'Tab'
+    },
+    {
+        code: 'CapsLock',
+        key: 'CapsLock'
+    },
+    {
+        code: 'Backspace',
+        key: 'Backspace'
+    },
+    {
+        code: 'Enter',
+        key: 'Enter'
+    },
+    // function
+    {
+        code: 'Escape',
+        key: 'Escape'
+    },
+    // arrows
+    {
+        code: 'ArrowUp',
+        key: 'ArrowUp'
+    },
+    {
+        code: 'ArrowDown',
+        key: 'ArrowDown'
+    },
+    {
+        code: 'ArrowLeft',
+        key: 'ArrowLeft'
+    },
+    {
+        code: 'ArrowRight',
+        key: 'ArrowRight'
+    },
+    // control pad
+    {
+        code: 'Home',
+        key: 'Home'
+    },
+    {
+        code: 'End',
+        key: 'End'
+    },
+    {
+        code: 'Delete',
+        key: 'Delete'
+    },
+    {
+        code: 'PageUp',
+        key: 'PageUp'
+    },
+    {
+        code: 'PageDown',
+        key: 'PageDown'
+    },
+    // Special keys that are not part of a default US-layout but included for specific behavior
+    {
+        code: 'Fn',
+        key: 'Fn'
+    },
+    {
+        code: 'Symbol',
+        key: 'Symbol'
+    },
+    {
+        code: 'AltRight',
+        key: 'AltGraph'
+    }
+];
+
+exports.defaultKeyMap = defaultKeyMap;

package/dist/cjs/keyboard/parseKeyDef.js

@@ -0,0 +1,45 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var readNextDescriptor = require('../utils/keyDef/readNextDescriptor.js');
+
+/**
+ * Parse key definitions per `keyboardMap`
+ *
+ * Keys can be referenced by `{key}` or `{special}` as well as physical locations per `[code]`.
+ * Everything else will be interpreted as a typed character - e.g. `a`.
+ * Brackets `{` and `[` can be escaped by doubling - e.g. `foo[[bar` translates to `foo[bar`.
+ * Keeping the key pressed can be written as `{key>}`.
+ * When keeping the key pressed you can choose how long (how many keydown and keypress) the key is pressed `{key>3}`.
+ * You can then release the key per `{key>3/}` or keep it pressed and continue with the next key.
+ */ function parseKeyDef(keyboardMap, text) {
+    const defs = [];
+    do {
+        var _keyboardMap_find;
+        const { type, descriptor, consumedLength, releasePrevious, releaseSelf = true, repeat } = readNextDescriptor.readNextDescriptor(text, 'keyboard');
+        const keyDef = (_keyboardMap_find = keyboardMap.find((def)=>{
+            if (type === '[') {
+                var _def_code;
+                return ((_def_code = def.code) === null || _def_code === void 0 ? void 0 : _def_code.toLowerCase()) === descriptor.toLowerCase();
+            } else if (type === '{') {
+                var _def_key;
+                return ((_def_key = def.key) === null || _def_key === void 0 ? void 0 : _def_key.toLowerCase()) === descriptor.toLowerCase();
+            }
+            return def.key === descriptor;
+        })) !== null && _keyboardMap_find !== void 0 ? _keyboardMap_find : {
+            key: 'Unknown',
+            code: 'Unknown',
+            [type === '[' ? 'code' : 'key']: descriptor
+        };
+        defs.push({
+            keyDef,
+            releasePrevious,
+            releaseSelf,
+            repeat
+        });
+        text = text.slice(consumedLength);
+    }while (text)
+    return defs;
+}
+
+exports.parseKeyDef = parseKeyDef;

package/dist/cjs/options.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var PointerEventsCheckLevel = /*#__PURE__*/ function(PointerEventsCheckLevel) {
+    /**
+   * Check pointer events on every user interaction that triggers a bunch of events.
+   * E.g. once for releasing a mouse button even though this triggers `pointerup`, `mouseup`, `click`, etc...
+   */ PointerEventsCheckLevel[PointerEventsCheckLevel["EachTrigger"] = 4] = "EachTrigger";
+    /** Check each target once per call to pointer (related) API */ PointerEventsCheckLevel[PointerEventsCheckLevel["EachApiCall"] = 2] = "EachApiCall";
+    /** Check each event target once */ PointerEventsCheckLevel[PointerEventsCheckLevel["EachTarget"] = 1] = "EachTarget";
+    /** No pointer events check */ PointerEventsCheckLevel[PointerEventsCheckLevel["Never"] = 0] = "Never";
+    return PointerEventsCheckLevel;
+}({});
+
+exports.PointerEventsCheckLevel = PointerEventsCheckLevel;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}