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

package/dist/cjs/pointer/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var level = require('../utils/misc/level.js');
+var wait = require('../utils/misc/wait.js');
+var parseKeyDef = require('./parseKeyDef.js');
+
+async function pointer(input) {
+    const { pointerMap } = this.config;
+    const actions = [];
+    (Array.isArray(input) ? input : [
+        input
+    ]).forEach((actionInput)=>{
+        if (typeof actionInput === 'string') {
+            actions.push(...parseKeyDef.parseKeyDef(pointerMap, actionInput));
+        } else if ('keys' in actionInput) {
+            actions.push(...parseKeyDef.parseKeyDef(pointerMap, actionInput.keys).map((i)=>({
+                    ...actionInput,
+                    ...i
+                })));
+        } else {
+            actions.push(actionInput);
+        }
+    });
+    for(let i = 0; i < actions.length; i++){
+        await wait.wait(this.config);
+        await pointerAction(this, actions[i]);
+    }
+    this.system.pointer.resetClickCount();
+}
+async function pointerAction(instance, action) {
+    var _action_target, _action_coords, _action_node, _action_offset;
+    var _previousPosition_caret, _previousPosition_caret1;
+    const pointerName = 'pointerName' in action && action.pointerName ? action.pointerName : 'keyDef' in action ? instance.system.pointer.getPointerName(action.keyDef) : 'mouse';
+    const previousPosition = instance.system.pointer.getPreviousPosition(pointerName);
+    const position = {
+        target: (_action_target = action.target) !== null && _action_target !== void 0 ? _action_target : getPrevTarget(instance, previousPosition),
+        coords: (_action_coords = action.coords) !== null && _action_coords !== void 0 ? _action_coords : previousPosition === null || previousPosition === void 0 ? void 0 : previousPosition.coords,
+        caret: {
+            node: (_action_node = action.node) !== null && _action_node !== void 0 ? _action_node : hasCaretPosition(action) ? undefined : previousPosition === null || previousPosition === void 0 ? void 0 : (_previousPosition_caret = previousPosition.caret) === null || _previousPosition_caret === void 0 ? void 0 : _previousPosition_caret.node,
+            offset: (_action_offset = action.offset) !== null && _action_offset !== void 0 ? _action_offset : hasCaretPosition(action) ? undefined : previousPosition === null || previousPosition === void 0 ? void 0 : (_previousPosition_caret1 = previousPosition.caret) === null || _previousPosition_caret1 === void 0 ? void 0 : _previousPosition_caret1.offset
+        }
+    };
+    if ('keyDef' in action) {
+        if (instance.system.pointer.isKeyPressed(action.keyDef)) {
+            level.setLevelRef(instance, level.ApiLevel.Trigger);
+            await instance.system.pointer.release(instance, action.keyDef, position);
+        }
+        if (!action.releasePrevious) {
+            level.setLevelRef(instance, level.ApiLevel.Trigger);
+            await instance.system.pointer.press(instance, action.keyDef, position);
+            if (action.releaseSelf) {
+                level.setLevelRef(instance, level.ApiLevel.Trigger);
+                await instance.system.pointer.release(instance, action.keyDef, position);
+            }
+        }
+    } else {
+        level.setLevelRef(instance, level.ApiLevel.Trigger);
+        await instance.system.pointer.move(instance, pointerName, position);
+    }
+}
+function hasCaretPosition(action) {
+    var _ref, _action_target;
+    return !!((_ref = (_action_target = action.target) !== null && _action_target !== void 0 ? _action_target : action.node) !== null && _ref !== void 0 ? _ref : action.offset !== undefined);
+}
+function getPrevTarget(instance, position) {
+    var _position_target;
+    if (!position) {
+        throw new Error('This pointer has no previous position. Provide a target property!');
+    }
+    return (_position_target = position.target) !== null && _position_target !== void 0 ? _position_target : instance.config.document.body;
+}
+
+exports.pointer = pointer;

package/dist/cjs/pointer/keyMap.js

@@ -0,0 +1,33 @@
+'use strict';
+
+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'
+    }
+];
+
+exports.defaultKeyMap = defaultKeyMap;

package/dist/cjs/pointer/parseKeyDef.js

@@ -0,0 +1,23 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var readNextDescriptor = require('../utils/keyDef/readNextDescriptor.js');
+
+function parseKeyDef(pointerMap, keys) {
+    const defs = [];
+    do {
+        const { descriptor, consumedLength, releasePrevious, releaseSelf = true } = readNextDescriptor.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;
+}
+
+exports.parseKeyDef = parseKeyDef;

package/dist/cjs/setup/api.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var click = require('../convenience/click.js');
+var hover = require('../convenience/hover.js');
+var tab = require('../convenience/tab.js');
+var index$1 = require('../keyboard/index.js');
+var copy = require('../clipboard/copy.js');
+var cut = require('../clipboard/cut.js');
+var paste = require('../clipboard/paste.js');
+var index = require('../pointer/index.js');
+var clear = require('../utility/clear.js');
+var selectOptions = require('../utility/selectOptions.js');
+var type = require('../utility/type.js');
+var upload = require('../utility/upload.js');
+
+const userEventApi = {
+    click: click.click,
+    dblClick: click.dblClick,
+    tripleClick: click.tripleClick,
+    hover: hover.hover,
+    unhover: hover.unhover,
+    tab: tab.tab,
+    keyboard: index$1.keyboard,
+    copy: copy.copy,
+    cut: cut.cut,
+    paste: paste.paste,
+    pointer: index.pointer,
+    clear: clear.clear,
+    deselectOptions: selectOptions.deselectOptions,
+    selectOptions: selectOptions.selectOptions,
+    type: type.type,
+    upload: upload.upload
+};
+
+exports.userEventApi = userEventApi;

package/dist/cjs/setup/directApi.js

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

package/dist/cjs/setup/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var setup = require('./setup.js');
+var directApi = require('./directApi.js');
+
+const userEvent = {
+    ...directApi,
+    setup: setup.setupMain
+};
+
+exports.userEvent = userEvent;

package/dist/cjs/setup/setup.js

@@ -0,0 +1,125 @@
+'use strict';
+
+var patchFocus = require('../document/patchFocus.js');
+var prepareDocument = require('../document/prepareDocument.js');
+var dispatchEvent = require('../event/dispatchEvent.js');
+var Clipboard = require('../utils/dataTransfer/Clipboard.js');
+var getWindow = require('../utils/misc/getWindow.js');
+var getDocumentFromNode = require('../utils/misc/getDocumentFromNode.js');
+var level = require('../utils/misc/level.js');
+var wait = require('../utils/misc/wait.js');
+var options = require('../options.js');
+require('@testing-library/dom');
+var keyMap$1 = require('../keyboard/keyMap.js');
+var keyMap = require('../pointer/keyMap.js');
+var index = require('../system/index.js');
+var api = require('./api.js');
+var wrapAsync = require('./wrapAsync.js');
+
+/**
+ * Default options applied when API is called per `userEvent.anyApi()`
+ */ const defaultOptionsDirect = {
+    applyAccept: true,
+    autoModify: true,
+    delay: 0,
+    document: globalThis.document,
+    keyboardMap: keyMap$1.defaultKeyMap,
+    pointerMap: keyMap.defaultKeyMap,
+    pointerEventsCheck: options.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.prepareDocument(config.document);
+    patchFocus.patchFocus(getWindow.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;
+    Clipboard.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.prepareDocument(config.document);
+    patchFocus.patchFocus(getWindow.getWindow(config.document).HTMLElement);
+    const system = (_ref = pointerState !== null && pointerState !== void 0 ? pointerState : keyboardState) !== null && _ref !== void 0 ? _ref : new index.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) {
+        level.setLevelRef(instance, level.ApiLevel.Call);
+        return wrapAsync.wrapAsync(()=>impl.apply(instance, args).then(async (ret)=>{
+                await wait.wait(instance.config);
+                return ret;
+            }));
+    }
+    Object.defineProperty(method, 'name', {
+        get: ()=>impl.name
+    });
+    return method;
+}
+function createInstance(config, system = new index.System()) {
+    const instance = {};
+    Object.assign(instance, {
+        config,
+        dispatchEvent: dispatchEvent.dispatchEvent.bind(instance),
+        dispatchUIEvent: dispatchEvent.dispatchUIEvent.bind(instance),
+        system,
+        levelRefs: {},
+        ...api.userEventApi
+    });
+    return {
+        instance,
+        api: {
+            ...Object.fromEntries(Object.entries(api.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.getDocumentFromNode(node)) !== null && _ref !== void 0 ? _ref : defaults.document;
+}
+
+exports.createConfig = createConfig;
+exports.createInstance = createInstance;
+exports.setupDirect = setupDirect;
+exports.setupMain = setupMain;
+exports.setupSub = setupSub;

package/dist/cjs/setup/wrapAsync.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var dom = require('@testing-library/dom');
+
+/**
+ * Wrap an internal Promise
+ */ function wrapAsync(implementation) {
+    return dom.getConfig().asyncWrapper(implementation);
+}
+
+exports.wrapAsync = wrapAsync;

package/dist/cjs/system/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var keyboard = require('./keyboard.js');
+var index = require('./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 keyboard.KeyboardHost(this));
+        _define_property(this, "pointer", new index.PointerHost(this));
+    }
+}
+
+exports.System = System;

package/dist/cjs/system/keyboard.js

@@ -0,0 +1,165 @@
+'use strict';
+
+require('../utils/dataTransfer/Clipboard.js');
+var getActiveElement = require('../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 = getActiveElement.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(getActiveElement.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(getActiveElement.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;
+    }
+}
+
+exports.DOM_KEY_LOCATION = DOM_KEY_LOCATION;
+exports.KeyboardHost = KeyboardHost;

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

@@ -0,0 +1,80 @@
+'use strict';
+
+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;
+}
+
+exports.Buttons = Buttons;
+exports.MouseButton = MouseButton;
+exports.MouseButtonFlip = MouseButtonFlip;
+exports.getMouseButtonId = getMouseButtonId;
+exports.getMouseEventButton = getMouseEventButton;