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

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2020 Giorgio Polvara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @depup/testing-library__user-event
+
+> Dependency-bumped version of [@testing-library/user-event](https://www.npmjs.com/package/@testing-library/user-event)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/testing-library__user-event
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@testing-library/user-event](https://www.npmjs.com/package/@testing-library/user-event) @ 14.6.3 |
+| Processed | 2026-08-04 |
+| Smoke test | failed |
+| Deps updated | 0 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@testing-library/user-event
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,5 @@
+{
+  "bumped": {},
+  "timestamp": "2026-08-04T00:39:39.331Z",
+  "totalUpdated": 0
+}

package/dist/cjs/clipboard/copy.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var Clipboard = require('../utils/dataTransfer/Clipboard.js');
+var copySelection = require('../document/copySelection.js');
+
+async function copy() {
+    var _doc_activeElement;
+    const doc = this.config.document;
+    const target = (_doc_activeElement = doc.activeElement) !== null && _doc_activeElement !== void 0 ? _doc_activeElement : /* istanbul ignore next */ doc.body;
+    const clipboardData = copySelection.copySelection(target);
+    if (clipboardData.items.length === 0) {
+        return;
+    }
+    if (this.dispatchUIEvent(target, 'copy', {
+        clipboardData
+    }) && this.config.writeToClipboard) {
+        await Clipboard.writeDataTransferToClipboard(doc, clipboardData);
+    }
+    return clipboardData;
+}
+
+exports.copy = copy;

package/dist/cjs/clipboard/cut.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var Clipboard = require('../utils/dataTransfer/Clipboard.js');
+var copySelection = require('../document/copySelection.js');
+
+async function cut() {
+    var _doc_activeElement;
+    const doc = this.config.document;
+    const target = (_doc_activeElement = doc.activeElement) !== null && _doc_activeElement !== void 0 ? _doc_activeElement : /* istanbul ignore next */ doc.body;
+    const clipboardData = copySelection.copySelection(target);
+    if (clipboardData.items.length === 0) {
+        return;
+    }
+    if (this.dispatchUIEvent(target, 'cut', {
+        clipboardData
+    }) && this.config.writeToClipboard) {
+        await Clipboard.writeDataTransferToClipboard(target.ownerDocument, clipboardData);
+    }
+    return clipboardData;
+}
+
+exports.cut = cut;

package/dist/cjs/clipboard/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var copy = require('./copy.js');
+var cut = require('./cut.js');
+var paste = require('./paste.js');
+
+
+
+exports.copy = copy.copy;
+exports.cut = cut.cut;
+exports.paste = paste.paste;

package/dist/cjs/clipboard/paste.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var DataTransfer = require('../utils/dataTransfer/DataTransfer.js');
+var Clipboard = require('../utils/dataTransfer/Clipboard.js');
+var getWindow = require('../utils/misc/getWindow.js');
+
+async function paste(clipboardData) {
+    var _doc_activeElement, _ref;
+    const doc = this.config.document;
+    const target = (_doc_activeElement = doc.activeElement) !== null && _doc_activeElement !== void 0 ? _doc_activeElement : /* istanbul ignore next */ doc.body;
+    const dataTransfer = (_ref = typeof clipboardData === 'string' ? getClipboardDataFromString(doc, clipboardData) : clipboardData) !== null && _ref !== void 0 ? _ref : await Clipboard.readDataTransferFromClipboard(doc).catch(()=>{
+        throw new Error('`userEvent.paste()` without `clipboardData` requires the `ClipboardAPI` to be available.');
+    });
+    this.dispatchUIEvent(target, 'paste', {
+        clipboardData: dataTransfer
+    });
+}
+function getClipboardDataFromString(doc, text) {
+    const dt = DataTransfer.createDataTransfer(getWindow.getWindow(doc));
+    dt.setData('text', text);
+    return dt;
+}
+
+exports.paste = paste;

package/dist/cjs/convenience/click.js

@@ -0,0 +1,35 @@
+'use strict';
+
+async function click(element) {
+    const pointerIn = [];
+    if (!this.config.skipHover) {
+        pointerIn.push({
+            target: element
+        });
+    }
+    pointerIn.push({
+        keys: '[MouseLeft]',
+        target: element
+    });
+    return this.pointer(pointerIn);
+}
+async function dblClick(element) {
+    return this.pointer([
+        {
+            target: element
+        },
+        '[MouseLeft][MouseLeft]'
+    ]);
+}
+async function tripleClick(element) {
+    return this.pointer([
+        {
+            target: element
+        },
+        '[MouseLeft][MouseLeft][MouseLeft]'
+    ]);
+}
+
+exports.click = click;
+exports.dblClick = dblClick;
+exports.tripleClick = tripleClick;

package/dist/cjs/convenience/hover.js

@@ -0,0 +1,19 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var cssPointerEvents = require('../utils/pointer/cssPointerEvents.js');
+
+async function hover(element) {
+    return this.pointer({
+        target: element
+    });
+}
+async function unhover(element) {
+    cssPointerEvents.assertPointerEvents(this, this.system.pointer.getMouseTarget(this));
+    return this.pointer({
+        target: element.ownerDocument.body
+    });
+}
+
+exports.hover = hover;
+exports.unhover = unhover;

package/dist/cjs/convenience/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var click = require('./click.js');
+var hover = require('./hover.js');
+var tab = require('./tab.js');
+
+
+
+exports.click = click.click;
+exports.dblClick = click.dblClick;
+exports.tripleClick = click.tripleClick;
+exports.hover = hover.hover;
+exports.unhover = hover.unhover;
+exports.tab = tab.tab;

package/dist/cjs/convenience/tab.js

@@ -0,0 +1,7 @@
+'use strict';
+
+async function tab({ shift } = {}) {
+    return this.keyboard(shift === true ? '{Shift>}{Tab}{/Shift}' : shift === false ? '[/ShiftLeft][/ShiftRight]{Tab}' : '{Tab}');
+}
+
+exports.tab = tab;

package/dist/cjs/document/UI.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const UIValue = Symbol('Displayed value in UI');
+const UISelection = Symbol('Displayed selection in UI');
+const InitialValue = Symbol('Initial value to compare on blur');
+function isUIValue(value) {
+    return typeof value === 'object' && UIValue in value;
+}
+function isUISelectionStart(start) {
+    return !!start && typeof start === 'object' && UISelection in start;
+}
+function setUIValue(element, value) {
+    if (element[InitialValue] === undefined) {
+        element[InitialValue] = element.value;
+    }
+    element[UIValue] = value;
+    element.value = Object.assign(new String(value), {
+        [UIValue]: true
+    });
+}
+function getUIValue(element) {
+    return element[UIValue] === undefined ? element.value : String(element[UIValue]);
+}
+/** Flag the IDL value as clean. This does not change the value. */ function setUIValueClean(element) {
+    element[UIValue] = undefined;
+}
+function clearInitialValue(element) {
+    element[InitialValue] = undefined;
+}
+function getInitialValue(element) {
+    return element[InitialValue];
+}
+function setUISelectionRaw(element, selection) {
+    element[UISelection] = selection;
+}
+function setUISelection(element, { focusOffset: focusOffsetParam, anchorOffset: anchorOffsetParam = focusOffsetParam }, mode = 'replace') {
+    const valueLength = getUIValue(element).length;
+    const sanitizeOffset = (o)=>Math.max(0, Math.min(valueLength, o));
+    const anchorOffset = mode === 'replace' || element[UISelection] === undefined ? sanitizeOffset(anchorOffsetParam) : element[UISelection].anchorOffset;
+    const focusOffset = sanitizeOffset(focusOffsetParam);
+    const startOffset = Math.min(anchorOffset, focusOffset);
+    const endOffset = Math.max(anchorOffset, focusOffset);
+    element[UISelection] = {
+        anchorOffset,
+        focusOffset
+    };
+    if (element.selectionStart === startOffset && element.selectionEnd === endOffset) {
+        return;
+    }
+    const startObj = Object.assign(new Number(startOffset), {
+        [UISelection]: true
+    });
+    try {
+        element.setSelectionRange(startObj, endOffset);
+    } catch  {
+    // DOMException for invalid state is expected when calling this
+    // on an element without support for setSelectionRange
+    }
+}
+function getUISelection(element) {
+    var _element_UISelection, _element_selectionStart, _element_selectionEnd;
+    const sel = (_element_UISelection = element[UISelection]) !== null && _element_UISelection !== void 0 ? _element_UISelection : {
+        anchorOffset: (_element_selectionStart = element.selectionStart) !== null && _element_selectionStart !== void 0 ? _element_selectionStart : 0,
+        focusOffset: (_element_selectionEnd = element.selectionEnd) !== null && _element_selectionEnd !== void 0 ? _element_selectionEnd : 0
+    };
+    return {
+        ...sel,
+        startOffset: Math.min(sel.anchorOffset, sel.focusOffset),
+        endOffset: Math.max(sel.anchorOffset, sel.focusOffset)
+    };
+}
+function hasUISelection(element) {
+    return !!element[UISelection];
+}
+/** Flag the IDL selection as clean. This does not change the selection. */ function setUISelectionClean(element) {
+    element[UISelection] = undefined;
+}
+
+exports.clearInitialValue = clearInitialValue;
+exports.getInitialValue = getInitialValue;
+exports.getUISelection = getUISelection;
+exports.getUIValue = getUIValue;
+exports.hasUISelection = hasUISelection;
+exports.isUISelectionStart = isUISelectionStart;
+exports.isUIValue = isUIValue;
+exports.setUISelection = setUISelection;
+exports.setUISelectionClean = setUISelectionClean;
+exports.setUISelectionRaw = setUISelectionRaw;
+exports.setUIValue = setUIValue;
+exports.setUIValueClean = setUIValueClean;

package/dist/cjs/document/copySelection.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var DataTransfer = require('../utils/dataTransfer/DataTransfer.js');
+require('../utils/dataTransfer/Clipboard.js');
+var getWindow = require('../utils/misc/getWindow.js');
+var selection = require('../utils/focus/selection.js');
+var UI = require('./UI.js');
+
+function copySelection(target) {
+    const data = selection.hasOwnSelection(target) ? {
+        'text/plain': readSelectedValueFromInput(target)
+    } : {
+        'text/plain': String(target.ownerDocument.getSelection())
+    };
+    const dt = DataTransfer.createDataTransfer(getWindow.getWindow(target));
+    for(const type in data){
+        if (data[type]) {
+            dt.setData(type, data[type]);
+        }
+    }
+    return dt;
+}
+function readSelectedValueFromInput(target) {
+    const sel = UI.getUISelection(target);
+    const val = UI.getUIValue(target);
+    return val.substring(sel.startOffset, sel.endOffset);
+}
+
+exports.copySelection = copySelection;

package/dist/cjs/document/getValueOrTextContent.js

@@ -0,0 +1,18 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var isContentEditable = require('../utils/edit/isContentEditable.js');
+var UI = require('./UI.js');
+
+function getValueOrTextContent(element) {
+    // istanbul ignore if
+    if (!element) {
+        return null;
+    }
+    if (isContentEditable.isContentEditable(element)) {
+        return element.textContent;
+    }
+    return UI.getUIValue(element);
+}
+
+exports.getValueOrTextContent = getValueOrTextContent;

package/dist/cjs/document/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var UI = require('./UI.js');
+var getValueOrTextContent = require('./getValueOrTextContent.js');
+var copySelection = require('./copySelection.js');
+var trackValue = require('./trackValue.js');
+
+
+
+exports.clearInitialValue = UI.clearInitialValue;
+exports.getUISelection = UI.getUISelection;
+exports.getUIValue = UI.getUIValue;
+exports.setUISelection = UI.setUISelection;
+exports.setUIValue = UI.setUIValue;
+exports.getValueOrTextContent = getValueOrTextContent.getValueOrTextContent;
+exports.copySelection = copySelection.copySelection;
+exports.commitValueAfterInput = trackValue.commitValueAfterInput;

package/dist/cjs/document/interceptor.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var isElementType = require('../utils/misc/isElementType.js');
+require('../utils/dataTransfer/Clipboard.js');
+var trackValue = require('./trackValue.js');
+var UI = require('./UI.js');
+
+const Interceptor = Symbol('Interceptor for programmatical calls');
+function prepareInterceptor(element, propName, interceptorImpl) {
+    const prototypeDescriptor = Object.getOwnPropertyDescriptor(element.constructor.prototype, propName);
+    const objectDescriptor = Object.getOwnPropertyDescriptor(element, propName);
+    const target = (prototypeDescriptor === null || prototypeDescriptor === void 0 ? void 0 : prototypeDescriptor.set) ? 'set' : 'value';
+    /* istanbul ignore if */ if (typeof (prototypeDescriptor === null || prototypeDescriptor === void 0 ? void 0 : prototypeDescriptor[target]) !== 'function' || prototypeDescriptor[target][Interceptor]) {
+        throw new Error(`Element ${element.tagName} does not implement "${String(propName)}".`);
+    }
+    function intercept(...args) {
+        const { applyNative = false, realArgs, then } = interceptorImpl.call(this, ...args);
+        const realFunc = (!applyNative && objectDescriptor || prototypeDescriptor)[target];
+        if (target === 'set') {
+            realFunc.call(this, realArgs);
+        } else {
+            realFunc.call(this, ...realArgs);
+        }
+        then === null || then === void 0 ? void 0 : then();
+    }
+    intercept[Interceptor] = Interceptor;
+    Object.defineProperty(element, propName, {
+        ...objectDescriptor !== null && objectDescriptor !== void 0 ? objectDescriptor : prototypeDescriptor,
+        [target]: intercept
+    });
+}
+function prepareValueInterceptor(element) {
+    prepareInterceptor(element, 'value', function interceptorImpl(v) {
+        const isUI = UI.isUIValue(v);
+        if (isUI) {
+            trackValue.startTrackValue(this);
+        }
+        return {
+            applyNative: !!isUI,
+            realArgs: sanitizeValue(this, v),
+            then: isUI ? undefined : ()=>trackValue.trackOrSetValue(this, String(v))
+        };
+    });
+}
+function sanitizeValue(element, v) {
+    // Workaround for JSDOM
+    if (isElementType.isElementType(element, 'input', {
+        type: 'number'
+    }) && String(v) !== '' && !Number.isNaN(Number(v))) {
+        // Setting value to "1." results in `null` in JSDOM
+        return String(Number(v));
+    }
+    return String(v);
+}
+function prepareSelectionInterceptor(element) {
+    prepareInterceptor(element, 'setSelectionRange', function interceptorImpl(start, ...others) {
+        const isUI = UI.isUISelectionStart(start);
+        return {
+            applyNative: !!isUI,
+            realArgs: [
+                Number(start),
+                ...others
+            ],
+            then: ()=>isUI ? undefined : UI.setUISelectionClean(element)
+        };
+    });
+    prepareInterceptor(element, 'selectionStart', function interceptorImpl(v) {
+        return {
+            realArgs: v,
+            then: ()=>UI.setUISelectionClean(element)
+        };
+    });
+    prepareInterceptor(element, 'selectionEnd', function interceptorImpl(v) {
+        return {
+            realArgs: v,
+            then: ()=>UI.setUISelectionClean(element)
+        };
+    });
+    prepareInterceptor(element, 'select', function interceptorImpl() {
+        return {
+            realArgs: [],
+            then: ()=>UI.setUISelectionRaw(element, {
+                    anchorOffset: 0,
+                    focusOffset: UI.getUIValue(element).length
+                })
+        };
+    });
+}
+function prepareRangeTextInterceptor(element) {
+    prepareInterceptor(element, 'setRangeText', function interceptorImpl(...realArgs) {
+        return {
+            realArgs,
+            then: ()=>{
+                UI.setUIValueClean(element);
+                UI.setUISelectionClean(element);
+            }
+        };
+    });
+}
+
+exports.prepareInterceptor = prepareInterceptor;
+exports.prepareRangeTextInterceptor = prepareRangeTextInterceptor;
+exports.prepareSelectionInterceptor = prepareSelectionInterceptor;
+exports.prepareValueInterceptor = prepareValueInterceptor;

package/dist/cjs/document/patchFocus.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var dispatchEvent = require('../event/dispatchEvent.js');
+require('../utils/dataTransfer/Clipboard.js');
+var getActiveElement = require('../utils/focus/getActiveElement.js');
+require('@testing-library/dom');
+
+const patched = Symbol('patched focus/blur methods');
+function patchFocus(HTMLElement) {
+    if (HTMLElement.prototype[patched]) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const { focus, blur } = HTMLElement.prototype;
+    Object.defineProperties(HTMLElement.prototype, {
+        focus: {
+            configurable: true,
+            value: patchedFocus,
+            writable: true
+        },
+        blur: {
+            configurable: true,
+            value: patchedBlur,
+            writable: true
+        },
+        [patched]: {
+            configurable: true,
+            get: ()=>({
+                    focus,
+                    blur
+                })
+        }
+    });
+    let activeCall;
+    function patchedFocus(options) {
+        if (this.ownerDocument.visibilityState !== 'hidden') {
+            return focus.call(this, options);
+        }
+        const blurred = getActiveTarget(this.ownerDocument);
+        if (blurred === this) {
+            return;
+        }
+        const thisCall = Symbol('focus call');
+        activeCall = thisCall;
+        if (blurred) {
+            blur.call(blurred);
+            dispatchEvent.dispatchDOMEvent(blurred, 'blur', {
+                relatedTarget: this
+            });
+            dispatchEvent.dispatchDOMEvent(blurred, 'focusout', {
+                relatedTarget: activeCall === thisCall ? this : null
+            });
+        }
+        if (activeCall === thisCall) {
+            focus.call(this, options);
+            dispatchEvent.dispatchDOMEvent(this, 'focus', {
+                relatedTarget: blurred
+            });
+        }
+        if (activeCall === thisCall) {
+            dispatchEvent.dispatchDOMEvent(this, 'focusin', {
+                relatedTarget: blurred
+            });
+        }
+    }
+    function patchedBlur() {
+        if (this.ownerDocument.visibilityState !== 'hidden') {
+            return blur.call(this);
+        }
+        const blurred = getActiveTarget(this.ownerDocument);
+        if (blurred !== this) {
+            return;
+        }
+        const thisCall = Symbol('blur call');
+        activeCall = thisCall;
+        blur.call(this);
+        dispatchEvent.dispatchDOMEvent(blurred, 'blur', {
+            relatedTarget: null
+        });
+        dispatchEvent.dispatchDOMEvent(blurred, 'focusout', {
+            relatedTarget: null
+        });
+    }
+}
+function getActiveTarget(document) {
+    const active = getActiveElement.getActiveElement(document);
+    return (active === null || active === void 0 ? void 0 : active.tagName) === 'BODY' ? null : active;
+}
+function restoreFocus(HTMLElement) {
+    if (HTMLElement.prototype[patched]) {
+        const { focus, blur } = HTMLElement.prototype[patched];
+        Object.defineProperties(HTMLElement.prototype, {
+            focus: {
+                configurable: true,
+                get: ()=>focus
+            },
+            blur: {
+                configurable: true,
+                get: ()=>blur
+            }
+        });
+    }
+}
+
+exports.patchFocus = patchFocus;
+exports.restoreFocus = restoreFocus;

package/dist/cjs/document/prepareDocument.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var dispatchEvent = require('../event/dispatchEvent.js');
+var isElementType = require('../utils/misc/isElementType.js');
+require('../utils/dataTransfer/Clipboard.js');
+var UI = require('./UI.js');
+require('@testing-library/dom');
+var interceptor = require('./interceptor.js');
+
+const isPrepared = Symbol('Node prepared with document state workarounds');
+function prepareDocument(document) {
+    if (document[isPrepared]) {
+        return;
+    }
+    document.addEventListener('focus', (e)=>{
+        const el = e.target;
+        prepareElement(el);
+    }, {
+        capture: true,
+        passive: true
+    });
+    // Our test environment defaults to `document.body` as `activeElement`.
+    // In other environments this might be `null` when preparing.
+    // istanbul ignore else
+    if (document.activeElement) {
+        prepareElement(document.activeElement);
+    }
+    document.addEventListener('blur', (e)=>{
+        const el = e.target;
+        const initialValue = UI.getInitialValue(el);
+        if (initialValue !== undefined) {
+            if (el.value !== initialValue) {
+                dispatchEvent.dispatchDOMEvent(el, 'change');
+            }
+            UI.clearInitialValue(el);
+        }
+    }, {
+        capture: true,
+        passive: true
+    });
+    document[isPrepared] = isPrepared;
+}
+function prepareElement(el) {
+    if (el[isPrepared]) {
+        return;
+    }
+    if (isElementType.isElementType(el, [
+        'input',
+        'textarea'
+    ])) {
+        interceptor.prepareValueInterceptor(el);
+        interceptor.prepareSelectionInterceptor(el);
+        interceptor.prepareRangeTextInterceptor(el);
+    }
+    el[isPrepared] = isPrepared;
+}
+
+exports.prepareDocument = prepareDocument;