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

package/dist/esm/pointer/keyMap.js

@@ -0,0 +1,31 @@
+const defaultKeyMap = [
+    {
+        name: 'MouseLeft',
+        pointerType: 'mouse',
+        button: 'primary'
+    },
+    {
+        name: 'MouseRight',
+        pointerType: 'mouse',
+        button: 'secondary'
+    },
+    {
+        name: 'MouseMiddle',
+        pointerType: 'mouse',
+        button: 'auxiliary'
+    },
+    {
+        name: 'TouchA',
+        pointerType: 'touch'
+    },
+    {
+        name: 'TouchB',
+        pointerType: 'touch'
+    },
+    {
+        name: 'TouchC',
+        pointerType: 'touch'
+    }
+];
+
+export { defaultKeyMap };

package/dist/esm/pointer/parseKeyDef.js

@@ -0,0 +1,21 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { readNextDescriptor } from '../utils/keyDef/readNextDescriptor.js';
+
+function parseKeyDef(pointerMap, keys) {
+    const defs = [];
+    do {
+        const { descriptor, consumedLength, releasePrevious, releaseSelf = true } = readNextDescriptor(keys, 'pointer');
+        const keyDef = pointerMap.find((p)=>p.name === descriptor);
+        if (keyDef) {
+            defs.push({
+                keyDef,
+                releasePrevious,
+                releaseSelf
+            });
+        }
+        keys = keys.slice(consumedLength);
+    }while (keys)
+    return defs;
+}
+
+export { parseKeyDef };

package/dist/esm/setup/api.js

@@ -0,0 +1,33 @@
+import { tripleClick, dblClick, click } from '../convenience/click.js';
+import { unhover, hover } from '../convenience/hover.js';
+import { tab } from '../convenience/tab.js';
+import { keyboard } from '../keyboard/index.js';
+import { copy } from '../clipboard/copy.js';
+import { cut } from '../clipboard/cut.js';
+import { paste } from '../clipboard/paste.js';
+import { pointer } from '../pointer/index.js';
+import { clear } from '../utility/clear.js';
+import { selectOptions, deselectOptions } from '../utility/selectOptions.js';
+import { type } from '../utility/type.js';
+import { upload } from '../utility/upload.js';
+
+const userEventApi = {
+    click,
+    dblClick,
+    tripleClick,
+    hover,
+    unhover,
+    tab,
+    keyboard,
+    copy,
+    cut,
+    paste,
+    pointer,
+    clear,
+    deselectOptions,
+    selectOptions,
+    type,
+    upload
+};
+
+export { userEventApi };

package/dist/esm/setup/directApi.js

@@ -0,0 +1,58 @@
+import { setupDirect } from './setup.js';
+
+function clear(element) {
+    return setupDirect().api.clear(element);
+}
+function click(element, options = {}) {
+    return setupDirect(options, element).api.click(element);
+}
+function copy(options = {}) {
+    return setupDirect(options).api.copy();
+}
+function cut(options = {}) {
+    return setupDirect(options).api.cut();
+}
+function dblClick(element, options = {}) {
+    return setupDirect(options).api.dblClick(element);
+}
+function deselectOptions(select, values, options = {}) {
+    return setupDirect(options).api.deselectOptions(select, values);
+}
+function hover(element, options = {}) {
+    return setupDirect(options).api.hover(element);
+}
+async function keyboard(text, options = {}) {
+    const { api, system } = setupDirect(options);
+    return api.keyboard(text).then(()=>system);
+}
+async function pointer(input, options = {}) {
+    const { api, system } = setupDirect(options);
+    return api.pointer(input).then(()=>system);
+}
+function paste(clipboardData, options) {
+    return setupDirect(options).api.paste(clipboardData);
+}
+function selectOptions(select, values, options = {}) {
+    return setupDirect(options).api.selectOptions(select, values);
+}
+function tripleClick(element, options = {}) {
+    return setupDirect(options).api.tripleClick(element);
+}
+function type(element, text, options = {}) {
+    return setupDirect(options, element).api.type(element, text, options);
+}
+function unhover(element, options = {}) {
+    const { api, system } = setupDirect(options);
+    system.pointer.setMousePosition({
+        target: element
+    });
+    return api.unhover(element);
+}
+function upload(element, fileOrFiles, options = {}) {
+    return setupDirect(options).api.upload(element, fileOrFiles);
+}
+function tab(options = {}) {
+    return setupDirect().api.tab(options);
+}
+
+export { clear, click, copy, cut, dblClick, deselectOptions, hover, keyboard, paste, pointer, selectOptions, tab, tripleClick, type, unhover, upload };

package/dist/esm/setup/index.js

@@ -0,0 +1,9 @@
+import { setupMain } from './setup.js';
+import * as directApi from './directApi.js';
+
+const userEvent = {
+    ...directApi,
+    setup: setupMain
+};
+
+export { userEvent };

package/dist/esm/setup/setup.js

@@ -0,0 +1,119 @@
+import { patchFocus } from '../document/patchFocus.js';
+import { prepareDocument } from '../document/prepareDocument.js';
+import { dispatchUIEvent, dispatchEvent } from '../event/dispatchEvent.js';
+import { attachClipboardStubToView } from '../utils/dataTransfer/Clipboard.js';
+import { getWindow } from '../utils/misc/getWindow.js';
+import { getDocumentFromNode } from '../utils/misc/getDocumentFromNode.js';
+import { setLevelRef, ApiLevel } from '../utils/misc/level.js';
+import { wait } from '../utils/misc/wait.js';
+import { PointerEventsCheckLevel } from '../options.js';
+import '@testing-library/dom';
+import { defaultKeyMap as defaultKeyMap$1 } from '../keyboard/keyMap.js';
+import { defaultKeyMap } from '../pointer/keyMap.js';
+import { System } from '../system/index.js';
+import { userEventApi } from './api.js';
+import { wrapAsync } from './wrapAsync.js';
+
+/**
+ * Default options applied when API is called per `userEvent.anyApi()`
+ */ const defaultOptionsDirect = {
+    applyAccept: true,
+    autoModify: true,
+    delay: 0,
+    document: globalThis.document,
+    keyboardMap: defaultKeyMap$1,
+    pointerMap: defaultKeyMap,
+    pointerEventsCheck: PointerEventsCheckLevel.EachApiCall,
+    skipAutoClose: false,
+    skipClick: false,
+    skipHover: false,
+    writeToClipboard: false,
+    advanceTimers: ()=>Promise.resolve()
+};
+/**
+ * Default options applied when API is called per `userEvent().anyApi()`
+ */ const defaultOptionsSetup = {
+    ...defaultOptionsDirect,
+    writeToClipboard: true
+};
+function createConfig(options = {}, defaults = defaultOptionsSetup, node) {
+    const document = getDocument(options, node, defaults);
+    return {
+        ...defaults,
+        ...options,
+        document
+    };
+}
+/**
+ * Start a "session" with userEvent.
+ * All APIs returned by this function share an input device state and a default configuration.
+ */ function setupMain(options = {}) {
+    var _config_document_defaultView;
+    const config = createConfig(options);
+    prepareDocument(config.document);
+    patchFocus(getWindow(config.document).HTMLElement);
+    const view = (_config_document_defaultView = config.document.defaultView) !== null && _config_document_defaultView !== void 0 ? _config_document_defaultView : /* istanbul ignore next */ globalThis.window;
+    attachClipboardStubToView(view);
+    return createInstance(config).api;
+}
+/**
+ * Setup in direct call per `userEvent.anyApi()`
+ */ function setupDirect({ keyboardState, pointerState, ...options } = {}, node) {
+    var _ref;
+    const config = createConfig(options, defaultOptionsDirect, node);
+    prepareDocument(config.document);
+    patchFocus(getWindow(config.document).HTMLElement);
+    const system = (_ref = pointerState !== null && pointerState !== void 0 ? pointerState : keyboardState) !== null && _ref !== void 0 ? _ref : new System();
+    return {
+        api: createInstance(config, system).api,
+        system
+    };
+}
+/**
+ * Create a set of callbacks with different default settings but the same state.
+ */ function setupSub(options) {
+    return createInstance({
+        ...this.config,
+        ...options
+    }, this.system).api;
+}
+function wrapAndBindImpl(instance, impl) {
+    function method(...args) {
+        setLevelRef(instance, ApiLevel.Call);
+        return wrapAsync(()=>impl.apply(instance, args).then(async (ret)=>{
+                await wait(instance.config);
+                return ret;
+            }));
+    }
+    Object.defineProperty(method, 'name', {
+        get: ()=>impl.name
+    });
+    return method;
+}
+function createInstance(config, system = new System()) {
+    const instance = {};
+    Object.assign(instance, {
+        config,
+        dispatchEvent: dispatchEvent.bind(instance),
+        dispatchUIEvent: dispatchUIEvent.bind(instance),
+        system,
+        levelRefs: {},
+        ...userEventApi
+    });
+    return {
+        instance,
+        api: {
+            ...Object.fromEntries(Object.entries(userEventApi).map(([name, api])=>[
+                    name,
+                    wrapAndBindImpl(instance, api)
+                ])),
+            setup: setupSub.bind(instance)
+        }
+    };
+}
+function getDocument(options, node, defaults) {
+    var _ref, _options_document;
+    return (_ref = (_options_document = options.document) !== null && _options_document !== void 0 ? _options_document : node && getDocumentFromNode(node)) !== null && _ref !== void 0 ? _ref : defaults.document;
+}
+
+export { createConfig, createInstance, setupDirect, setupMain, setupSub };

package/dist/esm/setup/wrapAsync.js

@@ -0,0 +1,9 @@
+import { getConfig } from '@testing-library/dom';
+
+/**
+ * Wrap an internal Promise
+ */ function wrapAsync(implementation) {
+    return getConfig().asyncWrapper(implementation);
+}
+
+export { wrapAsync };

package/dist/esm/system/index.js

@@ -0,0 +1,40 @@
+import { KeyboardHost } from './keyboard.js';
+import { PointerHost } from './pointer/index.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;
+}
+/**
+ * @internal Do not create/alter this by yourself as this type might be subject to changes.
+ */ class System {
+    getUIEventModifiers() {
+        return {
+            altKey: this.keyboard.modifiers.Alt,
+            ctrlKey: this.keyboard.modifiers.Control,
+            metaKey: this.keyboard.modifiers.Meta,
+            shiftKey: this.keyboard.modifiers.Shift,
+            modifierAltGraph: this.keyboard.modifiers.AltGraph,
+            modifierCapsLock: this.keyboard.modifiers.CapsLock,
+            modifierFn: this.keyboard.modifiers.Fn,
+            modifierFnLock: this.keyboard.modifiers.FnLock,
+            modifierNumLock: this.keyboard.modifiers.NumLock,
+            modifierScrollLock: this.keyboard.modifiers.ScrollLock,
+            modifierSymbol: this.keyboard.modifiers.Symbol,
+            modifierSymbolLock: this.keyboard.modifiers.SymbolLock
+        };
+    }
+    constructor(){
+        _define_property(this, "keyboard", new KeyboardHost(this));
+        _define_property(this, "pointer", new PointerHost(this));
+    }
+}
+
+export { System };

package/dist/esm/system/keyboard.js

@@ -0,0 +1,162 @@
+import '../utils/dataTransfer/Clipboard.js';
+import { getActiveElementOrBody } from '../utils/focus/getActiveElement.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;
+}
+var DOM_KEY_LOCATION = /*#__PURE__*/ function(DOM_KEY_LOCATION) {
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["STANDARD"] = 0] = "STANDARD";
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["LEFT"] = 1] = "LEFT";
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["RIGHT"] = 2] = "RIGHT";
+    DOM_KEY_LOCATION[DOM_KEY_LOCATION["NUMPAD"] = 3] = "NUMPAD";
+    return DOM_KEY_LOCATION;
+}({});
+const modifierKeys = [
+    'Alt',
+    'AltGraph',
+    'Control',
+    'Fn',
+    'Meta',
+    'Shift',
+    'Symbol'
+];
+function isModifierKey(key) {
+    return modifierKeys.includes(key);
+}
+const modifierLocks = [
+    'CapsLock',
+    'FnLock',
+    'NumLock',
+    'ScrollLock',
+    'SymbolLock'
+];
+function isModifierLock(key) {
+    return modifierLocks.includes(key);
+}
+class KeyboardHost {
+    isKeyPressed(keyDef) {
+        return this.pressed.has(String(keyDef.code));
+    }
+    getPressedKeys() {
+        return this.pressed.values().map((p)=>p.keyDef);
+    }
+    /** Press a key */ async keydown(instance, keyDef) {
+        const key = String(keyDef.key);
+        const code = String(keyDef.code);
+        const target = getActiveElementOrBody(instance.config.document);
+        this.setKeydownTarget(target);
+        this.pressed.add(code, keyDef);
+        if (isModifierKey(key)) {
+            this.modifiers[key] = true;
+        }
+        const unprevented = instance.dispatchUIEvent(target, 'keydown', {
+            key,
+            code
+        });
+        if (isModifierLock(key) && !this.modifiers[key]) {
+            this.modifiers[key] = true;
+            this.modifierLockStart[key] = true;
+        }
+        if (unprevented) {
+            this.pressed.setUnprevented(code);
+        }
+        if (unprevented && this.hasKeyPress(key)) {
+            instance.dispatchUIEvent(getActiveElementOrBody(instance.config.document), 'keypress', {
+                key,
+                code,
+                charCode: keyDef.key === 'Enter' ? 13 : String(keyDef.key).charCodeAt(0)
+            });
+        }
+    }
+    /** Release a key */ async keyup(instance, keyDef) {
+        const key = String(keyDef.key);
+        const code = String(keyDef.code);
+        const unprevented = this.pressed.isUnprevented(code);
+        this.pressed.delete(code);
+        if (isModifierKey(key) && !this.pressed.values().find((p)=>p.keyDef.key === key)) {
+            this.modifiers[key] = false;
+        }
+        instance.dispatchUIEvent(getActiveElementOrBody(instance.config.document), 'keyup', {
+            key,
+            code
+        }, !unprevented);
+        if (isModifierLock(key) && this.modifiers[key]) {
+            if (this.modifierLockStart[key]) {
+                this.modifierLockStart[key] = false;
+            } else {
+                this.modifiers[key] = false;
+            }
+        }
+    }
+    setKeydownTarget(target) {
+        if (target !== this.lastKeydownTarget) {
+            this.carryChar = '';
+        }
+        this.lastKeydownTarget = target;
+    }
+    hasKeyPress(key) {
+        return (key.length === 1 || key === 'Enter') && !this.modifiers.Control && !this.modifiers.Alt;
+    }
+    constructor(system){
+        _define_property(this, "system", void 0);
+        _define_property(this, "modifiers", {
+            Alt: false,
+            AltGraph: false,
+            CapsLock: false,
+            Control: false,
+            Fn: false,
+            FnLock: false,
+            Meta: false,
+            NumLock: false,
+            ScrollLock: false,
+            Shift: false,
+            Symbol: false,
+            SymbolLock: false
+        });
+        _define_property(this, "pressed", new class {
+            add(code, keyDef) {
+                var _this_registry, _code, _;
+                (_ = (_this_registry = this.registry)[_code = code]) !== null && _ !== void 0 ? _ : _this_registry[_code] = {
+                    keyDef,
+                    unpreventedDefault: false
+                };
+            }
+            has(code) {
+                return !!this.registry[code];
+            }
+            setUnprevented(code) {
+                const o = this.registry[code];
+                if (o) {
+                    o.unpreventedDefault = true;
+                }
+            }
+            isUnprevented(code) {
+                var _this_registry_code;
+                return !!((_this_registry_code = this.registry[code]) === null || _this_registry_code === void 0 ? void 0 : _this_registry_code.unpreventedDefault);
+            }
+            delete(code) {
+                delete this.registry[code];
+            }
+            values() {
+                return Object.values(this.registry);
+            }
+            constructor(){
+                _define_property(this, "registry", {});
+            }
+        }());
+        _define_property(this, "carryChar", '');
+        _define_property(this, "lastKeydownTarget", undefined);
+        _define_property(this, "modifierLockStart", {});
+        this.system = system;
+    }
+}
+
+export { DOM_KEY_LOCATION, KeyboardHost };

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

@@ -0,0 +1,74 @@
+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 Buttons {
+    getButtons() {
+        let v = 0;
+        for (const button of Object.keys(this.pressed)){
+            v |= 2 ** Number(button);
+        }
+        return v;
+    }
+    down(keyDef) {
+        const button = getMouseButtonId(keyDef.button);
+        if (button in this.pressed) {
+            this.pressed[button].push(keyDef);
+            return undefined;
+        }
+        this.pressed[button] = [
+            keyDef
+        ];
+        return button;
+    }
+    up(keyDef) {
+        const button = getMouseButtonId(keyDef.button);
+        if (button in this.pressed) {
+            this.pressed[button] = this.pressed[button].filter((k)=>k.name !== keyDef.name);
+            if (this.pressed[button].length === 0) {
+                delete this.pressed[button];
+                return button;
+            }
+        }
+        return undefined;
+    }
+    constructor(){
+        _define_property(this, "pressed", {});
+    }
+}
+const MouseButton = {
+    primary: 0,
+    secondary: 1,
+    auxiliary: 2,
+    back: 3,
+    X1: 3,
+    forward: 4,
+    X2: 4
+};
+function getMouseButtonId(button = 0) {
+    if (button in MouseButton) {
+        return MouseButton[button];
+    }
+    return Number(button);
+}
+// On the `MouseEvent.button` property auxiliary and secondary button are flipped compared to `MouseEvent.buttons`.
+const MouseButtonFlip = {
+    1: 2,
+    2: 1
+};
+function getMouseEventButton(button) {
+    button = getMouseButtonId(button);
+    if (button in MouseButtonFlip) {
+        return MouseButtonFlip[button];
+    }
+    return button;
+}
+
+export { Buttons, MouseButton, MouseButtonFlip, getMouseButtonId, getMouseEventButton };

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

@@ -0,0 +1,30 @@
+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 Device {
+    get countPressed() {
+        return this.pressedKeys.size;
+    }
+    isPressed(keyDef) {
+        return this.pressedKeys.has(keyDef.name);
+    }
+    addPressed(keyDef) {
+        return this.pressedKeys.add(keyDef.name);
+    }
+    removePressed(keyDef) {
+        return this.pressedKeys.delete(keyDef.name);
+    }
+    constructor(){
+        _define_property(this, "pressedKeys", new Set());
+    }
+}
+
+export { Device };