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

package/dist/esm/system/pointer/index.js

@@ -0,0 +1,154 @@
+import { Buttons } from './buttons.js';
+import { Device } from './device.js';
+import { Mouse } from './mouse.js';
+import { Pointer } from './pointer.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+class PointerHost {
+    isKeyPressed(keyDef) {
+        return this.devices.get(keyDef.pointerType).isPressed(keyDef);
+    }
+    async press(instance, keyDef, position) {
+        this.devices.get(keyDef.pointerType).addPressed(keyDef);
+        this.buttons.down(keyDef);
+        const pointerName = this.getPointerName(keyDef);
+        const pointer = keyDef.pointerType === 'touch' ? this.pointers.new(pointerName, keyDef.pointerType, this.buttons) : this.pointers.get(pointerName);
+        // TODO: deprecate the following implicit setting of position
+        pointer.position = position;
+        if (pointer.pointerType !== 'touch') {
+            this.mouse.position = position;
+        }
+        if (pointer.pointerType === 'touch') {
+            pointer.init(instance);
+        }
+        pointer.down(instance, keyDef.button);
+        if (pointer.pointerType !== 'touch') {
+            this.mouse.down(instance, keyDef, pointer.isPrevented);
+        }
+    }
+    async move(instance, pointerName, position) {
+        const pointer = this.pointers.get(pointerName);
+        // In (some?) browsers this order of events can be observed.
+        // This interweaving of events is probably unnecessary.
+        // While the order of mouse (or pointer) events is defined per spec,
+        // the order in which they interweave/follow on a user interaction depends on the implementation.
+        const pointermove = pointer.move(instance, position);
+        const mousemove = pointer.pointerType === 'touch' ? undefined : this.mouse.move(instance, position, pointer.isPrevented);
+        pointermove === null || pointermove === void 0 ? void 0 : pointermove.leave();
+        mousemove === null || mousemove === void 0 ? void 0 : mousemove.leave();
+        pointermove === null || pointermove === void 0 ? void 0 : pointermove.enter();
+        mousemove === null || mousemove === void 0 ? void 0 : mousemove.enter();
+        pointermove === null || pointermove === void 0 ? void 0 : pointermove.move();
+        mousemove === null || mousemove === void 0 ? void 0 : mousemove.move();
+    }
+    async release(instance, keyDef, position) {
+        const device = this.devices.get(keyDef.pointerType);
+        device.removePressed(keyDef);
+        this.buttons.up(keyDef);
+        const pointer = this.pointers.get(this.getPointerName(keyDef));
+        const isPrevented = pointer.isPrevented;
+        // TODO: deprecate the following implicit setting of position
+        pointer.position = position;
+        if (pointer.pointerType !== 'touch') {
+            this.mouse.position = position;
+        }
+        if (device.countPressed === 0) {
+            pointer.up(instance, keyDef.button);
+        }
+        if (pointer.pointerType === 'touch') {
+            pointer.release(instance);
+        }
+        if (pointer.pointerType === 'touch' && !pointer.isMultitouch) {
+            const mousemove = this.mouse.move(instance, position, isPrevented);
+            mousemove === null || mousemove === void 0 ? void 0 : mousemove.leave();
+            mousemove === null || mousemove === void 0 ? void 0 : mousemove.enter();
+            mousemove === null || mousemove === void 0 ? void 0 : mousemove.move();
+            this.mouse.down(instance, keyDef, isPrevented);
+        }
+        if (!pointer.isMultitouch) {
+            const mousemove = this.mouse.move(instance, position, isPrevented);
+            mousemove === null || mousemove === void 0 ? void 0 : mousemove.leave();
+            mousemove === null || mousemove === void 0 ? void 0 : mousemove.enter();
+            mousemove === null || mousemove === void 0 ? void 0 : mousemove.move();
+            this.mouse.up(instance, keyDef, isPrevented);
+        }
+    }
+    getPointerName(keyDef) {
+        return keyDef.pointerType === 'touch' ? keyDef.name : keyDef.pointerType;
+    }
+    getPreviousPosition(pointerName) {
+        return this.pointers.has(pointerName) ? this.pointers.get(pointerName).position : undefined;
+    }
+    resetClickCount() {
+        this.mouse.resetClickCount();
+    }
+    getMouseTarget(instance) {
+        var _this_mouse_position_target;
+        return (_this_mouse_position_target = this.mouse.position.target) !== null && _this_mouse_position_target !== void 0 ? _this_mouse_position_target : instance.config.document.body;
+    }
+    setMousePosition(position) {
+        this.mouse.position = position;
+        this.pointers.get('mouse').position = position;
+    }
+    constructor(system){
+        _define_property(this, "system", void 0);
+        _define_property(this, "mouse", void 0);
+        _define_property(this, "buttons", void 0);
+        _define_property(this, "devices", new class {
+            get(k) {
+                var _this_registry, _k, _;
+                return (_ = (_this_registry = this.registry)[_k = k]) !== null && _ !== void 0 ? _ : _this_registry[_k] = new Device();
+            }
+            constructor(){
+                _define_property(this, "registry", {});
+            }
+        }());
+        _define_property(this, "pointers", new class {
+            new(pointerName, pointerType, buttons) {
+                const isPrimary = pointerType !== 'touch' || !Object.values(this.registry).some((p)=>p.pointerType === 'touch' && !p.isCancelled);
+                if (!isPrimary) {
+                    Object.values(this.registry).forEach((p)=>{
+                        if (p.pointerType === pointerType && !p.isCancelled) {
+                            p.isMultitouch = true;
+                        }
+                    });
+                }
+                this.registry[pointerName] = new Pointer({
+                    pointerId: this.nextId++,
+                    pointerType,
+                    isPrimary
+                }, buttons);
+                return this.registry[pointerName];
+            }
+            get(pointerName) {
+                if (!this.has(pointerName)) {
+                    throw new Error(`Trying to access pointer "${pointerName}" which does not exist.`);
+                }
+                return this.registry[pointerName];
+            }
+            has(pointerName) {
+                return pointerName in this.registry;
+            }
+            constructor(){
+                _define_property(this, "registry", {});
+                _define_property(this, "nextId", 1);
+            }
+        }());
+        this.system = system;
+        this.buttons = new Buttons();
+        this.mouse = new Mouse();
+        this.pointers.new('mouse', 'mouse', this.buttons);
+    }
+}
+
+export { PointerHost };

package/dist/esm/system/pointer/mouse.js

@@ -0,0 +1,202 @@
+import '../../event/behavior/click.js';
+import '../../event/behavior/cut.js';
+import '../../event/behavior/keydown.js';
+import '../../event/behavior/keypress.js';
+import '../../event/behavior/keyup.js';
+import '../../event/behavior/paste.js';
+import '@testing-library/dom';
+import '../../utils/dataTransfer/Clipboard.js';
+import { isDisabled } from '../../utils/misc/isDisabled.js';
+import { getTreeDiff } from '../../utils/misc/getTreeDiff.js';
+import { focusElement } from '../../event/focus.js';
+import { setSelectionPerMouseDown } from '../../event/selection/setSelectionPerMouse.js';
+import { modifySelectionPerMouseMove } from '../../event/selection/modifySelectionPerMouse.js';
+import { getMouseEventButton, Buttons } from './buttons.js';
+import { isDifferentPointerPosition } from './shared.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+/**
+ * This object is the single "virtual" mouse that might be controlled by multiple different pointer devices.
+ */ class Mouse {
+    move(instance, position, /** Whether `preventDefault()` has been called on the `pointerdown` event */ isPrevented) {
+        const prevPosition = this.position;
+        const prevTarget = this.getTarget(instance);
+        this.position = position;
+        if (!isDifferentPointerPosition(prevPosition, position)) {
+            return;
+        }
+        const nextTarget = this.getTarget(instance);
+        const init = this.getEventInit('mousemove');
+        const [leave, enter] = getTreeDiff(prevTarget, nextTarget);
+        return {
+            leave: ()=>{
+                if (prevTarget !== nextTarget) {
+                    instance.dispatchUIEvent(prevTarget, 'mouseout', init);
+                    leave.forEach((el)=>instance.dispatchUIEvent(el, 'mouseleave', init));
+                }
+            },
+            enter: ()=>{
+                if (prevTarget !== nextTarget) {
+                    instance.dispatchUIEvent(nextTarget, 'mouseover', init);
+                    enter.forEach((el)=>instance.dispatchUIEvent(el, 'mouseenter', init));
+                }
+            },
+            move: ()=>{
+                if (isPrevented) {
+                    return;
+                }
+                instance.dispatchUIEvent(nextTarget, 'mousemove', init);
+                this.modifySelecting(instance);
+            }
+        };
+    }
+    down(instance, keyDef, /** Whether `preventDefault()` has been called on the `pointerdown` event */ isPrevented) {
+        const button = this.buttons.down(keyDef);
+        if (button === undefined) {
+            return;
+        }
+        const target = this.getTarget(instance);
+        this.buttonDownTarget[button] = target;
+        const init = this.getEventInit('mousedown', keyDef.button);
+        const disabled = isDisabled(target);
+        if (!isPrevented && (disabled || instance.dispatchUIEvent(target, 'mousedown', init))) {
+            this.startSelecting(instance, init.detail);
+            focusElement(target);
+        }
+        if (!disabled && getMouseEventButton(keyDef.button) === 2) {
+            instance.dispatchUIEvent(target, 'contextmenu', this.getEventInit('contextmenu', keyDef.button));
+        }
+    }
+    up(instance, keyDef, /** Whether `preventDefault()` has been called on the `pointerdown` event */ isPrevented) {
+        const button = this.buttons.up(keyDef);
+        if (button === undefined) {
+            return;
+        }
+        const target = this.getTarget(instance);
+        if (!isDisabled(target)) {
+            if (!isPrevented) {
+                const mouseUpInit = this.getEventInit('mouseup', keyDef.button);
+                instance.dispatchUIEvent(target, 'mouseup', mouseUpInit);
+                this.endSelecting();
+            }
+            const clickTarget = getTreeDiff(this.buttonDownTarget[button], target)[2][0];
+            if (clickTarget) {
+                const init = this.getEventInit('click', keyDef.button);
+                if (init.detail) {
+                    instance.dispatchUIEvent(clickTarget, init.button === 0 ? 'click' : 'auxclick', init);
+                    if (init.button === 0 && init.detail === 2) {
+                        instance.dispatchUIEvent(clickTarget, 'dblclick', {
+                            ...this.getEventInit('dblclick', keyDef.button),
+                            detail: init.detail
+                        });
+                    }
+                }
+            }
+        }
+    }
+    resetClickCount() {
+        this.clickCount.reset();
+    }
+    getEventInit(type, button) {
+        const init = {
+            ...this.position.coords
+        };
+        init.button = getMouseEventButton(button);
+        init.buttons = this.buttons.getButtons();
+        if (type === 'mousedown') {
+            init.detail = this.clickCount.getOnDown(init.button);
+        } else if (type === 'mouseup') {
+            init.detail = this.clickCount.getOnUp(init.button);
+        } else if (type === 'click' || type === 'auxclick') {
+            init.detail = this.clickCount.incOnClick(init.button);
+        }
+        return init;
+    }
+    getTarget(instance) {
+        var _this_position_target;
+        return (_this_position_target = this.position.target) !== null && _this_position_target !== void 0 ? _this_position_target : instance.config.document.body;
+    }
+    startSelecting(instance, clickCount) {
+        var _this_position_caret, _this_position_caret1;
+        // TODO: support extending range (shift)
+        this.selecting = setSelectionPerMouseDown({
+            document: instance.config.document,
+            target: this.getTarget(instance),
+            node: (_this_position_caret = this.position.caret) === null || _this_position_caret === void 0 ? void 0 : _this_position_caret.node,
+            offset: (_this_position_caret1 = this.position.caret) === null || _this_position_caret1 === void 0 ? void 0 : _this_position_caret1.offset,
+            clickCount
+        });
+    }
+    modifySelecting(instance) {
+        var _this_position_caret, _this_position_caret1;
+        if (!this.selecting) {
+            return;
+        }
+        modifySelectionPerMouseMove(this.selecting, {
+            document: instance.config.document,
+            target: this.getTarget(instance),
+            node: (_this_position_caret = this.position.caret) === null || _this_position_caret === void 0 ? void 0 : _this_position_caret.node,
+            offset: (_this_position_caret1 = this.position.caret) === null || _this_position_caret1 === void 0 ? void 0 : _this_position_caret1.offset
+        });
+    }
+    endSelecting() {
+        this.selecting = undefined;
+    }
+    constructor(){
+        _define_property(this, "position", {});
+        _define_property(this, "buttons", new Buttons());
+        _define_property(this, "selecting", void 0);
+        _define_property(this, "buttonDownTarget", {});
+        // According to spec the `detail` on click events should be the number
+        // of *consecutive* clicks with a specific button.
+        // On `mousedown` and `mouseup` it should be this number increased by one.
+        // But the browsers don't implement it this way.
+        // If another button is pressed,
+        //   in Webkit: the `mouseup` on the previously pressed button has `detail: 0` and no `click`/`auxclick`.
+        //   in Gecko: the `mouseup` and click events have the same detail as the `mousedown`.
+        // If there is a delay while a button is pressed,
+        // the `mouseup` and `click` are normal, but a following `mousedown` starts a new click count.
+        // We'll follow the minimal implementation of Webkit.
+        _define_property(this, "clickCount", new class {
+            incOnClick(button) {
+                const current = this.down[button] === undefined ? undefined : Number(this.down[button]) + 1;
+                this.count = this.count[button] === undefined ? {} : {
+                    [button]: Number(this.count[button]) + 1
+                };
+                return current;
+            }
+            getOnDown(button) {
+                var _this_count_button, _this_count_button1;
+                this.down = {
+                    [button]: (_this_count_button = this.count[button]) !== null && _this_count_button !== void 0 ? _this_count_button : 0
+                };
+                this.count = {
+                    [button]: (_this_count_button1 = this.count[button]) !== null && _this_count_button1 !== void 0 ? _this_count_button1 : 0
+                };
+                return Number(this.count[button]) + 1;
+            }
+            getOnUp(button) {
+                return this.down[button] === undefined ? undefined : Number(this.down[button]) + 1;
+            }
+            reset() {
+                this.count = {};
+            }
+            constructor(){
+                _define_property(this, "down", {});
+                _define_property(this, "count", {});
+            }
+        }());
+    }
+}
+
+export { Mouse };

package/dist/esm/system/pointer/pointer.js

@@ -0,0 +1,127 @@
+import '../../utils/dataTransfer/Clipboard.js';
+import { getTreeDiff } from '../../utils/misc/getTreeDiff.js';
+import { assertPointerEvents, hasPointerEvents } from '../../utils/pointer/cssPointerEvents.js';
+import { isDifferentPointerPosition } from './shared.js';
+import { getMouseEventButton } from './buttons.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+class Pointer {
+    init(instance) {
+        const target = this.getTarget(instance);
+        const [, enter] = getTreeDiff(null, target);
+        const init = this.getEventInit();
+        assertPointerEvents(instance, target);
+        instance.dispatchUIEvent(target, 'pointerover', init);
+        enter.forEach((el)=>instance.dispatchUIEvent(el, 'pointerenter', init));
+        return this;
+    }
+    move(instance, position) {
+        const prevPosition = this.position;
+        const prevTarget = this.getTarget(instance);
+        this.position = position;
+        if (!isDifferentPointerPosition(prevPosition, position)) {
+            return;
+        }
+        const nextTarget = this.getTarget(instance);
+        const init = this.getEventInit(-1);
+        const [leave, enter] = getTreeDiff(prevTarget, nextTarget);
+        return {
+            leave: ()=>{
+                if (hasPointerEvents(instance, prevTarget)) {
+                    if (prevTarget !== nextTarget) {
+                        instance.dispatchUIEvent(prevTarget, 'pointerout', init);
+                        leave.forEach((el)=>instance.dispatchUIEvent(el, 'pointerleave', init));
+                    }
+                }
+            },
+            enter: ()=>{
+                assertPointerEvents(instance, nextTarget);
+                if (prevTarget !== nextTarget) {
+                    instance.dispatchUIEvent(nextTarget, 'pointerover', init);
+                    enter.forEach((el)=>instance.dispatchUIEvent(el, 'pointerenter', init));
+                }
+            },
+            move: ()=>{
+                instance.dispatchUIEvent(nextTarget, 'pointermove', init);
+            }
+        };
+    }
+    down(instance, button = 0) {
+        if (this.isDown) {
+            return;
+        }
+        const target = this.getTarget(instance);
+        assertPointerEvents(instance, target);
+        this.isDown = true;
+        this.isPrevented = !instance.dispatchUIEvent(target, 'pointerdown', this.getEventInit(button));
+    }
+    up(instance, button = 0) {
+        if (!this.isDown) {
+            return;
+        }
+        const target = this.getTarget(instance);
+        assertPointerEvents(instance, target);
+        this.isPrevented = false;
+        this.isDown = false;
+        instance.dispatchUIEvent(target, 'pointerup', this.getEventInit(button));
+    }
+    release(instance) {
+        const target = this.getTarget(instance);
+        const [leave] = getTreeDiff(target, null);
+        const init = this.getEventInit();
+        // Currently there is no PointerEventsCheckLevel that would
+        // make this check not use the *asserted* cached value from `up`.
+        /* istanbul ignore else */ if (hasPointerEvents(instance, target)) {
+            instance.dispatchUIEvent(target, 'pointerout', init);
+            leave.forEach((el)=>instance.dispatchUIEvent(el, 'pointerleave', init));
+        }
+        this.isCancelled = true;
+    }
+    getTarget(instance) {
+        var _this_position_target;
+        return (_this_position_target = this.position.target) !== null && _this_position_target !== void 0 ? _this_position_target : instance.config.document.body;
+    }
+    getEventInit(/**
+     * The `button` that caused the event.
+     *
+     * This should be `-1` if the event is not caused by a button or touch/pen contact,
+     * e.g. a moving pointer.
+     */ button) {
+        return {
+            ...this.position.coords,
+            pointerId: this.pointerId,
+            pointerType: this.pointerType,
+            isPrimary: this.isPrimary,
+            button: getMouseEventButton(button),
+            buttons: this.buttons.getButtons()
+        };
+    }
+    constructor({ pointerId, pointerType, isPrimary }, buttons){
+        _define_property(this, "pointerId", void 0);
+        _define_property(this, "pointerType", void 0);
+        _define_property(this, "isPrimary", void 0);
+        _define_property(this, "buttons", void 0);
+        _define_property(this, "isMultitouch", false);
+        _define_property(this, "isCancelled", false);
+        _define_property(this, "isDown", false);
+        _define_property(this, "isPrevented", false);
+        _define_property(this, "position", {});
+        this.pointerId = pointerId;
+        this.pointerType = pointerType;
+        this.isPrimary = isPrimary;
+        this.isMultitouch = !isPrimary;
+        this.buttons = buttons;
+    }
+}
+
+export { Pointer };

package/dist/esm/system/pointer/shared.js

@@ -0,0 +1,6 @@
+function isDifferentPointerPosition(positionA, positionB) {
+    var _positionA_coords, _positionB_coords, _positionA_coords1, _positionB_coords1, _positionA_coords2, _positionB_coords2, _positionA_coords3, _positionB_coords3, _positionA_coords4, _positionB_coords4, _positionA_coords5, _positionB_coords5, _positionA_coords6, _positionB_coords6, _positionA_coords7, _positionB_coords7, _positionA_coords8, _positionB_coords8, _positionA_coords9, _positionB_coords9, _positionA_caret, _positionB_caret, _positionA_caret1, _positionB_caret1;
+    return positionA.target !== positionB.target || ((_positionA_coords = positionA.coords) === null || _positionA_coords === void 0 ? void 0 : _positionA_coords.x) !== ((_positionB_coords = positionB.coords) === null || _positionB_coords === void 0 ? void 0 : _positionB_coords.x) || ((_positionA_coords1 = positionA.coords) === null || _positionA_coords1 === void 0 ? void 0 : _positionA_coords1.y) !== ((_positionB_coords1 = positionB.coords) === null || _positionB_coords1 === void 0 ? void 0 : _positionB_coords1.y) || ((_positionA_coords2 = positionA.coords) === null || _positionA_coords2 === void 0 ? void 0 : _positionA_coords2.clientX) !== ((_positionB_coords2 = positionB.coords) === null || _positionB_coords2 === void 0 ? void 0 : _positionB_coords2.clientX) || ((_positionA_coords3 = positionA.coords) === null || _positionA_coords3 === void 0 ? void 0 : _positionA_coords3.clientY) !== ((_positionB_coords3 = positionB.coords) === null || _positionB_coords3 === void 0 ? void 0 : _positionB_coords3.clientY) || ((_positionA_coords4 = positionA.coords) === null || _positionA_coords4 === void 0 ? void 0 : _positionA_coords4.offsetX) !== ((_positionB_coords4 = positionB.coords) === null || _positionB_coords4 === void 0 ? void 0 : _positionB_coords4.offsetX) || ((_positionA_coords5 = positionA.coords) === null || _positionA_coords5 === void 0 ? void 0 : _positionA_coords5.offsetY) !== ((_positionB_coords5 = positionB.coords) === null || _positionB_coords5 === void 0 ? void 0 : _positionB_coords5.offsetY) || ((_positionA_coords6 = positionA.coords) === null || _positionA_coords6 === void 0 ? void 0 : _positionA_coords6.pageX) !== ((_positionB_coords6 = positionB.coords) === null || _positionB_coords6 === void 0 ? void 0 : _positionB_coords6.pageX) || ((_positionA_coords7 = positionA.coords) === null || _positionA_coords7 === void 0 ? void 0 : _positionA_coords7.pageY) !== ((_positionB_coords7 = positionB.coords) === null || _positionB_coords7 === void 0 ? void 0 : _positionB_coords7.pageY) || ((_positionA_coords8 = positionA.coords) === null || _positionA_coords8 === void 0 ? void 0 : _positionA_coords8.screenX) !== ((_positionB_coords8 = positionB.coords) === null || _positionB_coords8 === void 0 ? void 0 : _positionB_coords8.screenX) || ((_positionA_coords9 = positionA.coords) === null || _positionA_coords9 === void 0 ? void 0 : _positionA_coords9.screenY) !== ((_positionB_coords9 = positionB.coords) === null || _positionB_coords9 === void 0 ? void 0 : _positionB_coords9.screenY) || ((_positionA_caret = positionA.caret) === null || _positionA_caret === void 0 ? void 0 : _positionA_caret.node) !== ((_positionB_caret = positionB.caret) === null || _positionB_caret === void 0 ? void 0 : _positionB_caret.node) || ((_positionA_caret1 = positionA.caret) === null || _positionA_caret1 === void 0 ? void 0 : _positionA_caret1.offset) !== ((_positionB_caret1 = positionB.caret) === null || _positionB_caret1 === void 0 ? void 0 : _positionB_caret1.offset);
+}
+
+export { isDifferentPointerPosition };

package/dist/esm/utility/clear.js

@@ -0,0 +1,30 @@
+import '../event/behavior/click.js';
+import '../event/behavior/cut.js';
+import '../event/behavior/keydown.js';
+import '../event/behavior/keypress.js';
+import '../event/behavior/keyup.js';
+import '../event/behavior/paste.js';
+import '@testing-library/dom';
+import '../utils/dataTransfer/Clipboard.js';
+import { isEditable } from '../utils/edit/isEditable.js';
+import { isDisabled } from '../utils/misc/isDisabled.js';
+import { focusElement } from '../event/focus.js';
+import { input } from '../event/input.js';
+import { selectAll, isAllSelected } from '../event/selection/selectAll.js';
+
+async function clear(element) {
+    if (!isEditable(element) || isDisabled(element)) {
+        throw new Error('clear()` is only supported on editable elements.');
+    }
+    focusElement(element);
+    if (element.ownerDocument.activeElement !== element) {
+        throw new Error('The element to be cleared could not be focused.');
+    }
+    selectAll(element);
+    if (!isAllSelected(element)) {
+        throw new Error('The element content to be cleared could not be selected.');
+    }
+    input(this, element, '', 'deleteContentBackward');
+}
+
+export { clear };

package/dist/esm/utility/index.js

@@ -0,0 +1,4 @@
+export { clear } from './clear.js';
+export { deselectOptions, selectOptions } from './selectOptions.js';
+export { type } from './type.js';
+export { upload } from './upload.js';

package/dist/esm/utility/selectOptions.js

@@ -0,0 +1,111 @@
+import { getConfig } from '@testing-library/dom';
+import { isElementType } from '../utils/misc/isElementType.js';
+import '../utils/dataTransfer/Clipboard.js';
+import { isDisabled } from '../utils/misc/isDisabled.js';
+import { wait } from '../utils/misc/wait.js';
+import { hasPointerEvents } from '../utils/pointer/cssPointerEvents.js';
+import '../event/behavior/click.js';
+import '../event/behavior/cut.js';
+import '../event/behavior/keydown.js';
+import '../event/behavior/keypress.js';
+import '../event/behavior/keyup.js';
+import '../event/behavior/paste.js';
+import { focusElement } from '../event/focus.js';
+
+async function selectOptions(select, values) {
+    return selectOptionsBase.call(this, true, select, values);
+}
+async function deselectOptions(select, values) {
+    return selectOptionsBase.call(this, false, select, values);
+}
+async function selectOptionsBase(newValue, select, values) {
+    if (!newValue && !select.multiple) {
+        throw getConfig().getElementError(`Unable to deselect an option in a non-multiple select. Use selectOptions to change the selection instead.`, select);
+    }
+    const valArray = Array.isArray(values) ? values : [
+        values
+    ];
+    const allOptions = Array.from(select.querySelectorAll('option, [role="option"]'));
+    const selectedOptions = valArray.map((val)=>{
+        if (typeof val !== 'string' && allOptions.includes(val)) {
+            return val;
+        } else {
+            const matchingOption = allOptions.find((o)=>o.value === val || o.innerHTML === val);
+            if (matchingOption) {
+                return matchingOption;
+            } else {
+                throw getConfig().getElementError(`Value "${String(val)}" not found in options`, select);
+            }
+        }
+    }).filter((option)=>!isDisabled(option));
+    if (isDisabled(select) || !selectedOptions.length) return;
+    const selectOption = (option)=>{
+        option.selected = newValue;
+        this.dispatchUIEvent(select, 'input', {
+            bubbles: true,
+            cancelable: false,
+            composed: true
+        });
+        this.dispatchUIEvent(select, 'change');
+    };
+    if (isElementType(select, 'select')) {
+        if (select.multiple) {
+            for (const option of selectedOptions){
+                const withPointerEvents = this.config.pointerEventsCheck === 0 ? true : hasPointerEvents(this, option);
+                // events fired for multiple select are weird. Can't use hover...
+                if (withPointerEvents) {
+                    this.dispatchUIEvent(option, 'pointerover');
+                    this.dispatchUIEvent(select, 'pointerenter');
+                    this.dispatchUIEvent(option, 'mouseover');
+                    this.dispatchUIEvent(select, 'mouseenter');
+                    this.dispatchUIEvent(option, 'pointermove');
+                    this.dispatchUIEvent(option, 'mousemove');
+                    this.dispatchUIEvent(option, 'pointerdown');
+                    this.dispatchUIEvent(option, 'mousedown');
+                }
+                focusElement(select);
+                if (withPointerEvents) {
+                    this.dispatchUIEvent(option, 'pointerup');
+                    this.dispatchUIEvent(option, 'mouseup');
+                }
+                selectOption(option);
+                if (withPointerEvents) {
+                    this.dispatchUIEvent(option, 'click');
+                }
+                await wait(this.config);
+            }
+        } else if (selectedOptions.length === 1) {
+            const withPointerEvents = this.config.pointerEventsCheck === 0 ? true : hasPointerEvents(this, select);
+            // the click to open the select options
+            if (withPointerEvents) {
+                await this.click(select);
+            } else {
+                focusElement(select);
+            }
+            selectOption(selectedOptions[0]);
+            if (withPointerEvents) {
+                // the browser triggers another click event on the select for the click on the option
+                // this second click has no 'down' phase
+                this.dispatchUIEvent(select, 'pointerover');
+                this.dispatchUIEvent(select, 'pointerenter');
+                this.dispatchUIEvent(select, 'mouseover');
+                this.dispatchUIEvent(select, 'mouseenter');
+                this.dispatchUIEvent(select, 'pointerup');
+                this.dispatchUIEvent(select, 'mouseup');
+                this.dispatchUIEvent(select, 'click');
+            }
+            await wait(this.config);
+        } else {
+            throw getConfig().getElementError(`Cannot select multiple options on a non-multiple select`, select);
+        }
+    } else if (select.getAttribute('role') === 'listbox') {
+        for (const option of selectedOptions){
+            await this.click(option);
+            await this.unhover(option);
+        }
+    } else {
+        throw getConfig().getElementError(`Cannot select options on elements that are neither select nor listbox elements`, select);
+    }
+}
+
+export { deselectOptions, selectOptions };

package/dist/esm/utility/type.js

@@ -0,0 +1,21 @@
+import { releaseAllKeys } from '../keyboard/index.js';
+import '../utils/dataTransfer/Clipboard.js';
+import { setSelectionRange } from '../event/selection/setSelectionRange.js';
+
+async function type(element, text, { skipClick = this.config.skipClick, skipAutoClose = this.config.skipAutoClose, initialSelectionStart, initialSelectionEnd } = {}) {
+    // TODO: properly type guard
+    // we use this workaround for now to prevent changing behavior
+    if (element.disabled) return;
+    if (!skipClick) {
+        await this.click(element);
+    }
+    if (initialSelectionStart !== undefined) {
+        setSelectionRange(element, initialSelectionStart, initialSelectionEnd !== null && initialSelectionEnd !== void 0 ? initialSelectionEnd : initialSelectionStart);
+    }
+    await this.keyboard(text);
+    if (!skipAutoClose) {
+        await releaseAllKeys(this);
+    }
+}
+
+export { type };