@testing-library/user-event 10.3.2 → 10.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -7,195 +7,252 @@ exports.default = void 0;
7
7
 
8
8
  var _dom = require("@testing-library/dom");
9
9
 
10
- function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
10
+ function wait(time) {
11
+ return new Promise(resolve => setTimeout(() => resolve(), time));
12
+ }
11
13
 
12
- function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
14
+ function isMousePressEvent(event) {
15
+ return event === 'mousedown' || event === 'mouseup' || event === 'click' || event === 'dblclick';
16
+ }
13
17
 
14
- function _defineProperty(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; }
18
+ function invert(map) {
19
+ const res = {};
15
20
 
16
- function wait(time) {
17
- return new Promise(function (resolve) {
18
- setTimeout(() => resolve(), time);
19
- });
21
+ for (const key of Object.keys(map)) {
22
+ res[map[key]] = key;
23
+ }
24
+
25
+ return res;
26
+ } // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
27
+
28
+
29
+ const BUTTONS_TO_NAMES = {
30
+ 0: 'none',
31
+ 1: 'primary',
32
+ 2: 'secondary',
33
+ 4: 'auxiliary'
34
+ };
35
+ const NAMES_TO_BUTTONS = invert(BUTTONS_TO_NAMES); // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button
36
+
37
+ const BUTTON_TO_NAMES = {
38
+ 0: 'primary',
39
+ 1: 'auxiliary',
40
+ 2: 'secondary'
41
+ };
42
+ const NAMES_TO_BUTTON = invert(BUTTON_TO_NAMES);
43
+
44
+ function convertMouseButtons(event, init, property, mapping) {
45
+ if (!isMousePressEvent(event)) {
46
+ return 0;
47
+ }
48
+
49
+ if (init[property] != null) {
50
+ return init[property];
51
+ }
52
+
53
+ if (init.buttons != null) {
54
+ return mapping[BUTTONS_TO_NAMES[init.buttons]] || 0;
55
+ }
56
+
57
+ if (init.button != null) {
58
+ return mapping[BUTTON_TO_NAMES[init.button]] || 0;
59
+ }
60
+
61
+ return property != 'button' && isMousePressEvent(event) ? 1 : 0;
20
62
  }
21
63
 
22
- function findTagInParents(element, tagName) {
23
- if (element.parentNode == null) return undefined;
24
- if (element.parentNode.tagName === tagName) return element.parentNode;
25
- return findTagInParents(element.parentNode, tagName);
64
+ function getMouseEventOptions(event, init, clickCount = 0) {
65
+ init = init || {};
66
+ return { ...init,
67
+ // https://developer.mozilla.org/en-US/docs/Web/API/UIEvent/detail
68
+ detail: event === 'mousedown' || event === 'mouseup' ? 1 + clickCount : clickCount,
69
+ buttons: convertMouseButtons(event, init, 'buttons', NAMES_TO_BUTTONS),
70
+ button: convertMouseButtons(event, init, 'button', NAMES_TO_BUTTON)
71
+ };
26
72
  }
27
73
 
28
- function clickLabel(label) {
29
- _dom.fireEvent.mouseOver(label);
74
+ function clickLabel(label, init) {
75
+ _dom.fireEvent.mouseOver(label, getMouseEventOptions('mouseover', init));
30
76
 
31
- _dom.fireEvent.mouseMove(label);
77
+ _dom.fireEvent.mouseMove(label, getMouseEventOptions('mousemove', init));
32
78
 
33
- _dom.fireEvent.mouseDown(label);
79
+ _dom.fireEvent.mouseDown(label, getMouseEventOptions('mousedown', init));
34
80
 
35
- _dom.fireEvent.mouseUp(label);
81
+ _dom.fireEvent.mouseUp(label, getMouseEventOptions('mouseup', init));
36
82
 
37
- if (label.htmlFor) {
38
- const input = document.getElementById(label.htmlFor);
39
- input.focus();
83
+ _dom.fireEvent.click(label, getMouseEventOptions('click', init)); // clicking the label will trigger a click of the label.control
84
+ // however, it will not focus the label.control so we have to do it
85
+ // ourselves.
40
86
 
41
- _dom.fireEvent.click(label);
42
- } else {
43
- const input = label.querySelector("input,textarea,select");
44
- input.focus();
45
- label.focus();
46
87
 
47
- _dom.fireEvent.click(label);
48
- }
88
+ if (label.control) label.control.focus();
49
89
  }
50
90
 
51
- function clickBooleanElement(element) {
91
+ function clickBooleanElement(element, init) {
52
92
  if (element.disabled) return;
53
93
 
54
- _dom.fireEvent.mouseOver(element);
94
+ _dom.fireEvent.mouseOver(element, getMouseEventOptions('mouseover', init));
55
95
 
56
- _dom.fireEvent.mouseMove(element);
96
+ _dom.fireEvent.mouseMove(element, getMouseEventOptions('mousemove', init));
57
97
 
58
- _dom.fireEvent.mouseDown(element);
98
+ _dom.fireEvent.mouseDown(element, getMouseEventOptions('mousedown', init));
59
99
 
60
100
  _dom.fireEvent.focus(element);
61
101
 
62
- _dom.fireEvent.mouseUp(element);
102
+ _dom.fireEvent.mouseUp(element, getMouseEventOptions('mouseup', init));
63
103
 
64
- _dom.fireEvent.click(element);
104
+ _dom.fireEvent.click(element, getMouseEventOptions('click', init));
65
105
  }
66
106
 
67
107
  function clickElement(element, previousElement, init) {
68
- _dom.fireEvent.mouseOver(element);
108
+ _dom.fireEvent.mouseOver(element, getMouseEventOptions('mouseover', init));
69
109
 
70
- _dom.fireEvent.mouseMove(element);
110
+ _dom.fireEvent.mouseMove(element, getMouseEventOptions('mousemove', init));
71
111
 
72
- const wasAnotherElementFocused = previousElement !== element.ownerDocument.body && previousElement !== element;
112
+ const continueDefaultHandling = _dom.fireEvent.mouseDown(element, getMouseEventOptions('mousedown', init));
73
113
 
74
- const continueDefaultHandling = _dom.fireEvent.mouseDown(element);
114
+ const shouldFocus = element.ownerDocument.activeElement !== element;
75
115
 
76
116
  if (continueDefaultHandling) {
77
- wasAnotherElementFocused && previousElement.blur();
78
- previousElement !== element && element.focus();
117
+ if (previousElement) previousElement.blur();
118
+ if (shouldFocus) element.focus();
79
119
  }
80
120
 
81
- _dom.fireEvent.mouseUp(element);
121
+ _dom.fireEvent.mouseUp(element, getMouseEventOptions('mouseup', init));
82
122
 
83
- _dom.fireEvent.click(element, init);
123
+ _dom.fireEvent.click(element, getMouseEventOptions('click', init, 1));
84
124
 
85
- const labelAncestor = findTagInParents(element, "LABEL");
86
- labelAncestor && clickLabel(labelAncestor);
125
+ const parentLabel = element.closest('label');
126
+ if (parentLabel == null ? void 0 : parentLabel.control) parentLabel == null ? void 0 : parentLabel.control.focus == null ? void 0 : parentLabel.control.focus();
87
127
  }
88
128
 
89
- function dblClickElement(element, previousElement) {
90
- _dom.fireEvent.mouseOver(element);
129
+ function dblClickElement(element, previousElement, init) {
130
+ _dom.fireEvent.mouseOver(element, getMouseEventOptions('mouseover', init));
91
131
 
92
- _dom.fireEvent.mouseMove(element);
132
+ _dom.fireEvent.mouseMove(element, getMouseEventOptions('mousemove', init));
93
133
 
94
- const wasAnotherElementFocused = previousElement !== element.ownerDocument.body && previousElement !== element;
134
+ const continueDefaultHandling = _dom.fireEvent.mouseDown(element, getMouseEventOptions('mousedown', init));
95
135
 
96
- const continueDefaultHandling = _dom.fireEvent.mouseDown(element);
136
+ const shouldFocus = element.ownerDocument.activeElement !== element;
97
137
 
98
138
  if (continueDefaultHandling) {
99
- wasAnotherElementFocused && previousElement.blur();
100
- previousElement !== element && element.focus();
139
+ if (previousElement) previousElement.blur();
140
+ if (shouldFocus) element.focus();
101
141
  }
102
142
 
103
- _dom.fireEvent.mouseUp(element);
143
+ _dom.fireEvent.mouseUp(element, getMouseEventOptions('mouseup', init));
104
144
 
105
- _dom.fireEvent.click(element);
145
+ _dom.fireEvent.click(element, getMouseEventOptions('click', init, 1));
106
146
 
107
- _dom.fireEvent.mouseDown(element);
147
+ const parentLabel = element.closest('label');
148
+ if (parentLabel == null ? void 0 : parentLabel.control) parentLabel == null ? void 0 : parentLabel.control.focus == null ? void 0 : parentLabel.control.focus();
108
149
 
109
- _dom.fireEvent.mouseUp(element);
150
+ _dom.fireEvent.mouseDown(element, getMouseEventOptions('mousedown', init, 1));
110
151
 
111
- _dom.fireEvent.click(element);
152
+ _dom.fireEvent.mouseUp(element, getMouseEventOptions('mouseup', init, 1));
112
153
 
113
- _dom.fireEvent.dblClick(element);
154
+ _dom.fireEvent.click(element, getMouseEventOptions('click', init, 2));
114
155
 
115
- const labelAncestor = findTagInParents(element, "LABEL");
116
- labelAncestor && clickLabel(labelAncestor);
156
+ _dom.fireEvent.dblClick(element, getMouseEventOptions('dblclick', init, 2));
117
157
  }
118
158
 
119
- function dblClickCheckbox(checkbox) {
120
- _dom.fireEvent.mouseOver(checkbox);
159
+ function dblClickCheckbox(checkbox, init) {
160
+ _dom.fireEvent.mouseOver(checkbox, getMouseEventOptions('mouseover', init));
121
161
 
122
- _dom.fireEvent.mouseMove(checkbox);
162
+ _dom.fireEvent.mouseMove(checkbox, getMouseEventOptions('mousemove', init));
123
163
 
124
- _dom.fireEvent.mouseDown(checkbox);
164
+ _dom.fireEvent.mouseDown(checkbox, getMouseEventOptions('mousedown', init));
125
165
 
126
166
  _dom.fireEvent.focus(checkbox);
127
167
 
128
- _dom.fireEvent.mouseUp(checkbox);
168
+ _dom.fireEvent.mouseUp(checkbox, getMouseEventOptions('mouseup', init));
129
169
 
130
- _dom.fireEvent.click(checkbox);
170
+ _dom.fireEvent.click(checkbox, getMouseEventOptions('click', init, 1));
131
171
 
132
- _dom.fireEvent.mouseDown(checkbox);
172
+ _dom.fireEvent.mouseDown(checkbox, getMouseEventOptions('mousedown', init, 1));
133
173
 
134
- _dom.fireEvent.mouseUp(checkbox);
174
+ _dom.fireEvent.mouseUp(checkbox, getMouseEventOptions('mouseup', init, 1));
135
175
 
136
- _dom.fireEvent.click(checkbox);
176
+ _dom.fireEvent.click(checkbox, getMouseEventOptions('click', init, 2));
137
177
  }
138
178
 
139
- function selectOption(select, option) {
140
- _dom.fireEvent.mouseOver(option);
179
+ function selectOption(select, option, init) {
180
+ _dom.fireEvent.mouseOver(option, getMouseEventOptions('mouseover', init));
141
181
 
142
- _dom.fireEvent.mouseMove(option);
182
+ _dom.fireEvent.mouseMove(option, getMouseEventOptions('mousemove', init));
143
183
 
144
- _dom.fireEvent.mouseDown(option);
184
+ _dom.fireEvent.mouseDown(option, getMouseEventOptions('mousedown', init));
145
185
 
146
186
  _dom.fireEvent.focus(option);
147
187
 
148
- _dom.fireEvent.mouseUp(option);
188
+ _dom.fireEvent.mouseUp(option, getMouseEventOptions('mouseup', init));
149
189
 
150
- _dom.fireEvent.click(option);
190
+ _dom.fireEvent.click(option, getMouseEventOptions('click', init, 1));
151
191
 
152
192
  option.selected = true;
153
193
 
154
194
  _dom.fireEvent.change(select);
155
195
  }
156
196
 
157
- function fireChangeEvent(event) {
158
- _dom.fireEvent.change(event.target);
159
-
160
- event.target.removeEventListener("blur", fireChangeEvent);
161
- }
162
-
163
197
  const Keys = {
164
198
  Backspace: {
165
199
  keyCode: 8,
166
- code: "Backspace",
167
- key: "Backspace"
200
+ code: 'Backspace',
201
+ key: 'Backspace'
168
202
  }
169
203
  };
170
204
 
171
205
  function backspace(element) {
172
- const eventOptions = {
206
+ const keyboardEventOptions = {
173
207
  key: Keys.Backspace.key,
174
208
  keyCode: Keys.Backspace.keyCode,
175
209
  which: Keys.Backspace.keyCode
176
210
  };
177
211
 
178
- _dom.fireEvent.keyDown(element, eventOptions);
212
+ _dom.fireEvent.keyDown(element, keyboardEventOptions);
179
213
 
180
- _dom.fireEvent.keyUp(element, eventOptions);
214
+ _dom.fireEvent.keyUp(element, keyboardEventOptions);
181
215
 
182
216
  if (!element.readOnly) {
183
217
  _dom.fireEvent.input(element, {
184
- inputType: "deleteContentBackward"
218
+ inputType: 'deleteContentBackward'
219
+ }); // We need to call `fireEvent.change` _before_ we change `element.value`
220
+ // because `fireEvent.change` will use the element's native value setter
221
+ // (meaning it will avoid prototype overrides implemented by React). If we
222
+ // call `input.value = ""` first, React will swallow the change event (this
223
+ // is checked in the tests). `fireEvent.change` will only call the native
224
+ // value setter method if the event options include `{ target: { value }}`
225
+ // (https://github.com/testing-library/dom-testing-library/blob/8846eaf20972f8e41ed11f278948ac38a692c3f1/src/events.js#L29-L32).
226
+ //
227
+ // Also, we still must call `element.value = ""` after calling
228
+ // `fireEvent.change` because `fireEvent.change` will _only_ call the native
229
+ // `value` setter and not the prototype override defined by React, causing
230
+ // React's internal represetation of this state to get out of sync with the
231
+ // value set on `input.value`; calling `element.value` after will also call
232
+ // React's setter, keeping everything in sync.
233
+ //
234
+ // Comment either of these out or re-order them and see what parts of the
235
+ // tests fail for more context.
236
+
237
+
238
+ _dom.fireEvent.change(element, {
239
+ target: {
240
+ value: ''
241
+ }
185
242
  });
186
243
 
187
- element.value = ""; // when we add special keys to API, will need to respect selected range
244
+ element.value = '';
188
245
  }
189
246
  }
190
247
 
191
248
  function selectAll(element) {
192
- userEvent.dblClick(element); // simulate events (will not actually select)
249
+ dblClick(element); // simulate events (will not actually select)
193
250
 
194
251
  const elementType = element.type; // type is a readonly property on textarea, so check if element is an input before trying to modify it
195
252
 
196
253
  if (isInputElement(element)) {
197
254
  // setSelectionRange is not supported on certain types of inputs, e.g. "number" or "email"
198
- element.type = "text";
255
+ element.type = 'text';
199
256
  }
200
257
 
201
258
  element.setSelectionRange(0, element.value.length);
@@ -206,134 +263,140 @@ function selectAll(element) {
206
263
  }
207
264
 
208
265
  function isInputElement(element) {
209
- return element.tagName.toLowerCase() === "input";
266
+ return element.tagName.toLowerCase() === 'input';
210
267
  }
211
268
 
212
- const userEvent = {
213
- click(element, init) {
214
- const focusedElement = element.ownerDocument.activeElement;
215
- const wasAnotherElementFocused = focusedElement !== element.ownerDocument.body && focusedElement !== element;
269
+ function getPreviouslyFocusedElement(element) {
270
+ const focusedElement = element.ownerDocument.activeElement;
271
+ const wasAnotherElementFocused = focusedElement && focusedElement !== element.ownerDocument.body && focusedElement !== element;
272
+ return wasAnotherElementFocused ? focusedElement : null;
273
+ }
216
274
 
217
- if (wasAnotherElementFocused) {
218
- _dom.fireEvent.mouseMove(focusedElement);
275
+ function click(element, init) {
276
+ const previouslyFocusedElement = getPreviouslyFocusedElement(element);
219
277
 
220
- _dom.fireEvent.mouseLeave(focusedElement);
221
- }
278
+ if (previouslyFocusedElement) {
279
+ _dom.fireEvent.mouseMove(previouslyFocusedElement, getMouseEventOptions('mousemove', init));
280
+
281
+ _dom.fireEvent.mouseLeave(previouslyFocusedElement, getMouseEventOptions('mouseleave', init));
282
+ }
283
+
284
+ switch (element.tagName) {
285
+ case 'LABEL':
286
+ clickLabel(element, init);
287
+ break;
222
288
 
223
- switch (element.tagName) {
224
- case "LABEL":
225
- clickLabel(element);
289
+ case 'INPUT':
290
+ if (element.type === 'checkbox' || element.type === 'radio') {
291
+ clickBooleanElement(element, init);
226
292
  break;
293
+ }
227
294
 
228
- case "INPUT":
229
- if (element.type === "checkbox" || element.type === "radio") {
230
- clickBooleanElement(element);
231
- break;
232
- }
295
+ // eslint-disable-next-line no-fallthrough
233
296
 
234
- default:
235
- clickElement(element, focusedElement, init);
236
- }
237
- },
297
+ default:
298
+ clickElement(element, previouslyFocusedElement, init);
299
+ }
300
+ }
238
301
 
239
- dblClick(element) {
240
- const focusedElement = document.activeElement;
241
- const wasAnotherElementFocused = focusedElement !== document.body && focusedElement !== element;
302
+ function dblClick(element, init) {
303
+ const previouslyFocusedElement = getPreviouslyFocusedElement(element);
242
304
 
243
- if (wasAnotherElementFocused) {
244
- _dom.fireEvent.mouseMove(focusedElement);
305
+ if (previouslyFocusedElement) {
306
+ _dom.fireEvent.mouseMove(previouslyFocusedElement, getMouseEventOptions('mousemove', init));
245
307
 
246
- _dom.fireEvent.mouseLeave(focusedElement);
247
- }
308
+ _dom.fireEvent.mouseLeave(previouslyFocusedElement, getMouseEventOptions('mouseleave', init));
309
+ }
248
310
 
249
- switch (element.tagName) {
250
- case "INPUT":
251
- if (element.type === "checkbox") {
252
- dblClickCheckbox(element, wasAnotherElementFocused && focusedElement);
253
- break;
254
- }
311
+ switch (element.tagName) {
312
+ case 'INPUT':
313
+ if (element.type === 'checkbox') {
314
+ dblClickCheckbox(element, previouslyFocusedElement, init);
315
+ break;
316
+ }
255
317
 
256
- default:
257
- dblClickElement(element, focusedElement);
258
- }
259
- },
318
+ // eslint-disable-next-line no-fallthrough
260
319
 
261
- selectOptions(element, values) {
262
- const focusedElement = document.activeElement;
263
- const wasAnotherElementFocused = focusedElement !== document.body && focusedElement !== element;
320
+ default:
321
+ dblClickElement(element, previouslyFocusedElement, init);
322
+ }
323
+ }
264
324
 
265
- if (wasAnotherElementFocused) {
266
- _dom.fireEvent.mouseMove(focusedElement);
325
+ function selectOptions(element, values, init) {
326
+ const previouslyFocusedElement = getPreviouslyFocusedElement(element);
267
327
 
268
- _dom.fireEvent.mouseLeave(focusedElement);
269
- }
328
+ if (previouslyFocusedElement) {
329
+ _dom.fireEvent.mouseMove(previouslyFocusedElement, getMouseEventOptions('mousemove', init));
270
330
 
271
- clickElement(element, focusedElement);
272
- const valArray = Array.isArray(values) ? values : [values];
273
- const selectedOptions = Array.from(element.querySelectorAll("option")).filter(opt => valArray.includes(opt.value));
331
+ _dom.fireEvent.mouseLeave(previouslyFocusedElement, getMouseEventOptions('mouseleave', init));
332
+ }
274
333
 
275
- if (selectedOptions.length > 0) {
276
- if (element.multiple) {
277
- selectedOptions.forEach(option => selectOption(element, option));
278
- } else {
279
- selectOption(element, selectedOptions[0]);
280
- }
334
+ clickElement(element, previouslyFocusedElement, init);
335
+ const valArray = Array.isArray(values) ? values : [values];
336
+ const selectedOptions = Array.from(element.querySelectorAll('option')).filter(opt => valArray.includes(opt.value) || valArray.includes(opt));
337
+
338
+ if (selectedOptions.length > 0) {
339
+ if (element.multiple) {
340
+ selectedOptions.forEach(option => selectOption(element, option));
341
+ } else {
342
+ selectOption(element, selectedOptions[0]);
281
343
  }
282
- },
283
-
284
- clear(element) {
285
- if (element.disabled) return;
286
- selectAll(element);
287
- backspace(element);
288
- element.addEventListener("blur", fireChangeEvent);
289
- },
290
-
291
- async type(element, text, userOpts = {}) {
292
- if (element.disabled) return;
293
- const defaultOpts = {
294
- allAtOnce: false,
295
- delay: 0
296
- };
297
- const opts = Object.assign(defaultOpts, userOpts);
298
- const previousText = element.value;
299
- const computedText = element.maxLength > 0 ? text.slice(0, Math.max(element.maxLength - previousText.length, 0)) : text;
300
-
301
- if (opts.allAtOnce) {
302
- if (element.readOnly) return;
344
+ }
345
+ }
346
+
347
+ function clear(element) {
348
+ if (element.disabled) return;
349
+ selectAll(element);
350
+ backspace(element);
351
+ }
303
352
 
353
+ async function type(element, text, {
354
+ allAtOnce = false,
355
+ delay
356
+ } = {}) {
357
+ if (element.disabled) return;
358
+ const previousText = element.value;
359
+ const computedText = element.maxLength > 0 ? text.slice(0, Math.max(element.maxLength - previousText.length, 0)) : text;
360
+
361
+ if (allAtOnce) {
362
+ if (!element.readOnly) {
304
363
  _dom.fireEvent.input(element, {
305
364
  target: {
306
365
  value: previousText + computedText
307
366
  }
308
367
  });
309
- } else {
310
- let actuallyTyped = previousText;
368
+ }
369
+ } else {
370
+ let actuallyTyped = previousText;
371
+
372
+ for (let index = 0; index < text.length; index++) {
373
+ const char = text[index];
374
+ const key = char; // TODO: check if this also valid for characters with diacritic markers e.g. úé etc
311
375
 
312
- for (let index = 0; index < text.length; index++) {
313
- const char = text[index];
314
- const key = char; // TODO: check if this also valid for characters with diacritic markers e.g. úé etc
376
+ const keyCode = char.charCodeAt(0); // eslint-disable-next-line no-await-in-loop
315
377
 
316
- const keyCode = char.charCodeAt(0);
317
- if (opts.delay > 0) await wait(opts.delay);
378
+ if (delay > 0) await wait(delay);
318
379
 
319
- const downEvent = _dom.fireEvent.keyDown(element, {
320
- key: key,
321
- keyCode: keyCode,
322
- which: keyCode
380
+ const downEvent = _dom.fireEvent.keyDown(element, {
381
+ key,
382
+ keyCode,
383
+ which: keyCode
384
+ });
385
+
386
+ if (downEvent) {
387
+ const pressEvent = _dom.fireEvent.keyPress(element, {
388
+ key,
389
+ keyCode,
390
+ charCode: keyCode
323
391
  });
324
392
 
325
- if (downEvent) {
326
- const pressEvent = _dom.fireEvent.keyPress(element, {
327
- key: key,
328
- keyCode,
329
- charCode: keyCode
330
- });
393
+ const isTextPastThreshold = (actuallyTyped + key).length > (previousText + computedText).length;
331
394
 
332
- const isTextPastThreshold = (actuallyTyped + key).length > (previousText + computedText).length;
395
+ if (pressEvent && !isTextPastThreshold) {
396
+ actuallyTyped += key;
333
397
 
334
- if (pressEvent && !isTextPastThreshold) {
335
- actuallyTyped += key;
336
- if (!element.readOnly) _dom.fireEvent.input(element, {
398
+ if (!element.readOnly) {
399
+ _dom.fireEvent.input(element, {
337
400
  target: {
338
401
  value: actuallyTyped
339
402
  },
@@ -342,82 +405,93 @@ const userEvent = {
342
405
  });
343
406
  }
344
407
  }
345
-
346
- _dom.fireEvent.keyUp(element, {
347
- key: key,
348
- keyCode: keyCode,
349
- which: keyCode
350
- });
351
408
  }
352
- }
353
409
 
354
- element.addEventListener("blur", fireChangeEvent);
355
- },
356
-
357
- upload(element, fileOrFiles, {
358
- clickInit,
359
- changeInit
360
- } = {}) {
361
- if (element.disabled) return;
362
- const focusedElement = element.ownerDocument.activeElement;
363
- let files;
364
-
365
- if (element.tagName === "LABEL") {
366
- clickLabel(element);
367
- const inputElement = element.htmlFor ? document.getElementById(element.htmlFor) : querySelector("input");
368
- files = inputElement.multiple ? fileOrFiles : [fileOrFiles];
369
- } else {
370
- files = element.multiple ? fileOrFiles : [fileOrFiles];
371
- clickElement(element, focusedElement, clickInit);
410
+ _dom.fireEvent.keyUp(element, {
411
+ key,
412
+ keyCode,
413
+ which: keyCode
414
+ });
372
415
  }
416
+ }
417
+ }
373
418
 
374
- _dom.fireEvent.change(element, _objectSpread({
375
- target: {
376
- files: _objectSpread({
377
- length: files.length,
378
- item: index => files[index] || null
379
- }, files)
419
+ function upload(element, fileOrFiles, {
420
+ clickInit,
421
+ changeInit
422
+ } = {}) {
423
+ if (element.disabled) return;
424
+ const focusedElement = element.ownerDocument.activeElement;
425
+ let files;
426
+
427
+ if (element.tagName === 'LABEL') {
428
+ clickLabel(element);
429
+ files = element.control.multiple ? fileOrFiles : [fileOrFiles];
430
+ } else {
431
+ files = element.multiple ? fileOrFiles : [fileOrFiles];
432
+ clickElement(element, focusedElement, clickInit);
433
+ }
434
+
435
+ _dom.fireEvent.change(element, {
436
+ target: {
437
+ files: {
438
+ length: files.length,
439
+ item: index => files[index] || null,
440
+ ...files
380
441
  }
381
- }, changeInit));
382
- },
383
-
384
- tab({
385
- shift = false,
386
- focusTrap = document
387
- } = {}) {
388
- const focusableElements = focusTrap.querySelectorAll("input, button, select, textarea, a[href], [tabindex]");
389
- const enabledElements = Array.prototype.filter.call(focusableElements, function (el) {
390
- return el.getAttribute("tabindex") !== "-1" && !el.disabled;
391
- });
392
- if (enabledElements.length === 0) return;
393
- const orderedElements = enabledElements.map((el, idx) => ({
394
- el,
395
- idx
396
- })).sort((a, b) => {
397
- const tabIndexA = a.el.getAttribute("tabindex");
398
- const tabIndexB = b.el.getAttribute("tabindex");
399
- const diff = tabIndexA - tabIndexB;
400
- return diff !== 0 ? diff : a.idx - b.idx;
401
- });
402
- const index = orderedElements.findIndex(({
403
- el
404
- }) => el === document.activeElement);
405
- let nextIndex = shift ? index - 1 : index + 1;
406
- let defaultIndex = shift ? orderedElements.length - 1 : 0;
407
- const {
408
- el: next
409
- } = orderedElements[nextIndex] || orderedElements[defaultIndex];
410
-
411
- if (next.getAttribute("tabindex") === null) {
412
- next.setAttribute("tabindex", "0"); // jsdom requires tabIndex=0 for an item to become 'document.activeElement' (the browser does not)
413
-
414
- next.focus();
415
- next.removeAttribute("tabindex"); // leave no trace. :)
416
- } else {
417
- next.focus();
418
- }
442
+ },
443
+ ...changeInit
444
+ });
445
+ }
446
+
447
+ function tab({
448
+ shift = false,
449
+ focusTrap = document
450
+ } = {}) {
451
+ const focusableElements = focusTrap.querySelectorAll('input, button, select, textarea, a[href], [tabindex]');
452
+ const enabledElements = [...focusableElements].filter(el => el.getAttribute('tabindex') !== '-1' && !el.disabled);
453
+ if (enabledElements.length === 0) return;
454
+ const orderedElements = enabledElements.map((el, idx) => ({
455
+ el,
456
+ idx
457
+ })).sort((a, b) => {
458
+ const tabIndexA = a.el.getAttribute('tabindex');
459
+ const tabIndexB = b.el.getAttribute('tabindex');
460
+ const diff = tabIndexA - tabIndexB;
461
+ return diff === 0 ? a.idx - b.idx : diff;
462
+ });
463
+ const index = orderedElements.findIndex(({
464
+ el
465
+ }) => el === el.ownerDocument.activeElement);
466
+ const nextIndex = shift ? index - 1 : index + 1;
467
+ const defaultIndex = shift ? orderedElements.length - 1 : 0;
468
+ const {
469
+ el: next
470
+ } = orderedElements[nextIndex] || orderedElements[defaultIndex];
471
+
472
+ if (next.getAttribute('tabindex') === null) {
473
+ next.setAttribute('tabindex', '0'); // jsdom requires tabIndex=0 for an item to become 'document.activeElement'
474
+
475
+ next.focus();
476
+ next.removeAttribute('tabindex'); // leave no trace. :)
477
+ } else {
478
+ next.focus();
419
479
  }
480
+ }
420
481
 
482
+ const userEvent = {
483
+ click,
484
+ dblClick,
485
+ selectOptions,
486
+ clear,
487
+ type,
488
+ upload,
489
+ tab
421
490
  };
422
491
  var _default = userEvent;
492
+ /*
493
+ eslint
494
+ max-depth: ["error", 6],
495
+ */
496
+
423
497
  exports.default = _default;