@testing-library/user-event 12.2.1 → 12.5.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/type.js ADDED
@@ -0,0 +1,837 @@
1
+ "use strict";
2
+
3
+ Object.defineProperty(exports, "__esModule", {
4
+ value: true
5
+ });
6
+ exports.type = type;
7
+
8
+ var _dom = require("@testing-library/dom");
9
+
10
+ var _utils = require("./utils");
11
+
12
+ var _click = require("./click");
13
+
14
+ var _navigationKey = require("./keys/navigation-key");
15
+
16
+ // TODO: wrap in asyncWrapper
17
+ const modifierCallbackMap = { ...createModifierCallbackEntries({
18
+ name: 'shift',
19
+ key: 'Shift',
20
+ keyCode: 16,
21
+ modifierProperty: 'shiftKey'
22
+ }),
23
+ ...createModifierCallbackEntries({
24
+ name: 'ctrl',
25
+ key: 'Control',
26
+ keyCode: 17,
27
+ modifierProperty: 'ctrlKey'
28
+ }),
29
+ ...createModifierCallbackEntries({
30
+ name: 'alt',
31
+ key: 'Alt',
32
+ keyCode: 18,
33
+ modifierProperty: 'altKey'
34
+ }),
35
+ ...createModifierCallbackEntries({
36
+ name: 'meta',
37
+ key: 'Meta',
38
+ keyCode: 93,
39
+ modifierProperty: 'metaKey'
40
+ }),
41
+ // capslock is inline because of the need to fire both keydown and keyup on use, while preserving the modifier state.
42
+ '{capslock}': function ({
43
+ currentElement,
44
+ eventOverrides
45
+ }) {
46
+ const newEventOverrides = {
47
+ modifierCapsLock: true
48
+ };
49
+
50
+ _dom.fireEvent.keyDown(currentElement(), {
51
+ key: 'CapsLock',
52
+ keyCode: 20,
53
+ which: 20,
54
+ ...eventOverrides,
55
+ ...newEventOverrides
56
+ });
57
+
58
+ _dom.fireEvent.keyUp(currentElement(), {
59
+ key: 'CapsLock',
60
+ keyCode: 20,
61
+ which: 20,
62
+ ...eventOverrides,
63
+ ...newEventOverrides
64
+ });
65
+
66
+ return {
67
+ eventOverrides: newEventOverrides
68
+ };
69
+ },
70
+ '{/capslock}': function ({
71
+ currentElement,
72
+ eventOverrides
73
+ }) {
74
+ const newEventOverrides = {
75
+ modifierCapsLock: false
76
+ };
77
+
78
+ _dom.fireEvent.keyDown(currentElement(), {
79
+ key: 'CapsLock',
80
+ keyCode: 20,
81
+ which: 20,
82
+ ...eventOverrides,
83
+ ...newEventOverrides
84
+ });
85
+
86
+ _dom.fireEvent.keyUp(currentElement(), {
87
+ key: 'CapsLock',
88
+ keyCode: 20,
89
+ which: 20,
90
+ ...eventOverrides,
91
+ ...newEventOverrides
92
+ });
93
+
94
+ return {
95
+ eventOverrides: newEventOverrides
96
+ };
97
+ }
98
+ };
99
+ const specialCharCallbackMap = {
100
+ '{arrowleft}': (0, _navigationKey.navigationKey)('ArrowLeft'),
101
+ '{arrowright}': (0, _navigationKey.navigationKey)('ArrowRight'),
102
+ '{arrowdown}': handleArrowDown,
103
+ '{arrowup}': handleArrowUp,
104
+ '{enter}': handleEnter,
105
+ '{esc}': handleEsc,
106
+ '{del}': handleDel,
107
+ '{backspace}': handleBackspace,
108
+ '{selectall}': handleSelectall,
109
+ '{space}': handleSpace,
110
+ ' ': handleSpace
111
+ };
112
+
113
+ function wait(time) {
114
+ return new Promise(resolve => setTimeout(() => resolve(), time));
115
+ } // this needs to be wrapped in the event/asyncWrapper for React's act and angular's change detection
116
+ // depending on whether it will be async.
117
+
118
+
119
+ async function type(element, text, {
120
+ delay = 0,
121
+ ...options
122
+ } = {}) {
123
+ // we do not want to wrap in the asyncWrapper if we're not
124
+ // going to actually be doing anything async, so we only wrap
125
+ // if the delay is greater than 0
126
+ let result;
127
+
128
+ if (delay > 0) {
129
+ await (0, _dom.getConfig)().asyncWrapper(async () => {
130
+ result = await typeImpl(element, text, {
131
+ delay,
132
+ ...options
133
+ });
134
+ });
135
+ } else {
136
+ result = typeImpl(element, text, {
137
+ delay,
138
+ ...options
139
+ });
140
+ }
141
+
142
+ return result;
143
+ }
144
+
145
+ async function typeImpl(element, text, {
146
+ delay,
147
+ skipClick = false,
148
+ skipAutoClose = false,
149
+ initialSelectionStart,
150
+ initialSelectionEnd
151
+ }) {
152
+ if (element.disabled) return;
153
+ if (!skipClick) (0, _click.click)(element);
154
+
155
+ if ((0, _utils.isContentEditable)(element) && document.getSelection().rangeCount === 0) {
156
+ const range = document.createRange();
157
+ range.setStart(element, 0);
158
+ range.setEnd(element, 0);
159
+ document.getSelection().addRange(range);
160
+ } // The focused element could change between each event, so get the currently active element each time
161
+
162
+
163
+ const currentElement = () => (0, _utils.getActiveElement)(element.ownerDocument); // by default, a new element has it's selection start and end at 0
164
+ // but most of the time when people call "type", they expect it to type
165
+ // at the end of the current input value. So, if the selection start
166
+ // and end are both the default of 0, then we'll go ahead and change
167
+ // them to the length of the current value.
168
+ // the only time it would make sense to pass the initialSelectionStart or
169
+ // initialSelectionEnd is if you have an input with a value and want to
170
+ // explicitely start typing with the cursor at 0. Not super common.
171
+
172
+
173
+ const value = (0, _utils.getValue)(currentElement());
174
+ const {
175
+ selectionStart,
176
+ selectionEnd
177
+ } = (0, _utils.getSelectionRange)(element);
178
+
179
+ if (value != null && selectionStart === 0 && selectionEnd === 0) {
180
+ (0, _utils.setSelectionRangeIfNecessary)(currentElement(), initialSelectionStart != null ? initialSelectionStart : value.length, initialSelectionEnd != null ? initialSelectionEnd : value.length);
181
+ }
182
+
183
+ const eventCallbacks = function () {
184
+ const callbacks = [];
185
+ let remainingString = text;
186
+
187
+ while (remainingString) {
188
+ const {
189
+ callback,
190
+ remainingString: newRemainingString
191
+ } = getNextCallback(remainingString, skipAutoClose);
192
+ callbacks.push(callback);
193
+ remainingString = newRemainingString;
194
+ }
195
+
196
+ return callbacks;
197
+ }();
198
+
199
+ await async function (callbacks) {
200
+ const eventOverrides = {};
201
+ let prevWasMinus, prevWasPeriod, prevValue, typedValue;
202
+
203
+ for (const callback of callbacks) {
204
+ if (delay > 0) await wait(delay);
205
+
206
+ if (!currentElement().disabled) {
207
+ const returnValue = callback({
208
+ currentElement,
209
+ prevWasMinus,
210
+ prevWasPeriod,
211
+ prevValue,
212
+ eventOverrides,
213
+ typedValue
214
+ });
215
+ Object.assign(eventOverrides, returnValue == null ? void 0 : returnValue.eventOverrides);
216
+ prevWasMinus = returnValue == null ? void 0 : returnValue.prevWasMinus;
217
+ prevWasPeriod = returnValue == null ? void 0 : returnValue.prevWasPeriod;
218
+ prevValue = returnValue == null ? void 0 : returnValue.prevValue;
219
+ typedValue = returnValue == null ? void 0 : returnValue.typedValue;
220
+ }
221
+ }
222
+ }(eventCallbacks);
223
+ }
224
+
225
+ function getNextCallback(remainingString, skipAutoClose) {
226
+ const modifierCallback = getModifierCallback(remainingString, skipAutoClose);
227
+
228
+ if (modifierCallback) {
229
+ return modifierCallback;
230
+ }
231
+
232
+ const specialCharCallback = getSpecialCharCallback(remainingString);
233
+
234
+ if (specialCharCallback) {
235
+ return specialCharCallback;
236
+ }
237
+
238
+ return getTypeCallback(remainingString);
239
+ }
240
+
241
+ function getModifierCallback(remainingString, skipAutoClose) {
242
+ const modifierKey = Object.keys(modifierCallbackMap).find(key => remainingString.startsWith(key));
243
+
244
+ if (!modifierKey) {
245
+ return null;
246
+ }
247
+
248
+ const callback = modifierCallbackMap[modifierKey]; // if this modifier has an associated "close" callback and the developer
249
+ // doesn't close it themselves, then we close it for them automatically
250
+ // Effectively if they send in: '{alt}a' then we type: '{alt}a{/alt}'
251
+
252
+ if (!skipAutoClose && callback.closeName && !remainingString.includes(callback.closeName)) {
253
+ remainingString += callback.closeName;
254
+ }
255
+
256
+ remainingString = remainingString.slice(modifierKey.length);
257
+ return {
258
+ callback,
259
+ remainingString
260
+ };
261
+ }
262
+
263
+ function getSpecialCharCallback(remainingString) {
264
+ const specialChar = Object.keys(specialCharCallbackMap).find(key => remainingString.startsWith(key));
265
+
266
+ if (!specialChar) {
267
+ return null;
268
+ }
269
+
270
+ return {
271
+ callback: specialCharCallbackMap[specialChar],
272
+ remainingString: remainingString.slice(specialChar.length)
273
+ };
274
+ }
275
+
276
+ function getTypeCallback(remainingString) {
277
+ const character = remainingString[0];
278
+ return {
279
+ callback: context => typeCharacter(character, context),
280
+ remainingString: remainingString.slice(1)
281
+ };
282
+ }
283
+
284
+ function setSelectionRange({
285
+ currentElement,
286
+ newValue,
287
+ newSelectionStart
288
+ }) {
289
+ // if we *can* change the selection start, then we will if the new value
290
+ // is the same as the current value (so it wasn't programatically changed
291
+ // when the fireEvent.input was triggered).
292
+ // The reason we have to do this at all is because it actually *is*
293
+ // programmatically changed by fireEvent.input, so we have to simulate the
294
+ // browser's default behavior
295
+ const value = (0, _utils.getValue)(currentElement());
296
+
297
+ if (value === newValue) {
298
+ (0, _utils.setSelectionRangeIfNecessary)(currentElement(), newSelectionStart, newSelectionStart);
299
+ } else {
300
+ // If the currentValue is different than the expected newValue and we *can*
301
+ // change the selection range, than we should set it to the length of the
302
+ // currentValue to ensure that the browser behavior is mimicked.
303
+ (0, _utils.setSelectionRangeIfNecessary)(currentElement(), value.length, value.length);
304
+ }
305
+ }
306
+
307
+ function fireInputEventIfNeeded({
308
+ currentElement,
309
+ newValue,
310
+ newSelectionStart,
311
+ eventOverrides
312
+ }) {
313
+ const prevValue = (0, _utils.getValue)(currentElement());
314
+
315
+ if (!currentElement().readOnly && !(0, _utils.isClickable)(currentElement()) && newValue !== prevValue) {
316
+ if ((0, _utils.isContentEditable)(currentElement())) {
317
+ _dom.fireEvent.input(currentElement(), {
318
+ target: {
319
+ textContent: newValue
320
+ },
321
+ ...eventOverrides
322
+ });
323
+ } else {
324
+ _dom.fireEvent.input(currentElement(), {
325
+ target: {
326
+ value: newValue
327
+ },
328
+ ...eventOverrides
329
+ });
330
+ }
331
+
332
+ setSelectionRange({
333
+ currentElement,
334
+ newValue,
335
+ newSelectionStart
336
+ });
337
+ }
338
+
339
+ return {
340
+ prevValue
341
+ };
342
+ }
343
+
344
+ function typeCharacter(char, {
345
+ currentElement,
346
+ prevWasMinus = false,
347
+ prevWasPeriod = false,
348
+ prevValue = '',
349
+ typedValue = '',
350
+ eventOverrides
351
+ }) {
352
+ const key = char; // TODO: check if this also valid for characters with diacritic markers e.g. úé etc
353
+
354
+ const keyCode = char.charCodeAt(0);
355
+ let nextPrevWasMinus, nextPrevWasPeriod;
356
+ const textToBeTyped = typedValue + char;
357
+
358
+ const keyDownDefaultNotPrevented = _dom.fireEvent.keyDown(currentElement(), {
359
+ key,
360
+ keyCode,
361
+ which: keyCode,
362
+ ...eventOverrides
363
+ });
364
+
365
+ if (keyDownDefaultNotPrevented) {
366
+ const keyPressDefaultNotPrevented = _dom.fireEvent.keyPress(currentElement(), {
367
+ key,
368
+ keyCode,
369
+ charCode: keyCode,
370
+ ...eventOverrides
371
+ });
372
+
373
+ if ((0, _utils.getValue)(currentElement()) != null && keyPressDefaultNotPrevented) {
374
+ let newEntry = char;
375
+
376
+ if (prevWasMinus) {
377
+ newEntry = `-${char}`;
378
+ } else if (prevWasPeriod) {
379
+ newEntry = `${prevValue}.${char}`;
380
+ }
381
+
382
+ if ((0, _utils.isValidDateValue)(currentElement(), textToBeTyped)) {
383
+ newEntry = textToBeTyped;
384
+ }
385
+
386
+ const timeNewEntry = (0, _utils.buildTimeValue)(textToBeTyped);
387
+
388
+ if ((0, _utils.isValidInputTimeValue)(currentElement(), timeNewEntry)) {
389
+ newEntry = timeNewEntry;
390
+ }
391
+
392
+ const inputEvent = fireInputEventIfNeeded({ ...(0, _utils.calculateNewValue)(newEntry, currentElement()),
393
+ eventOverrides: {
394
+ data: key,
395
+ inputType: 'insertText',
396
+ ...eventOverrides
397
+ },
398
+ currentElement
399
+ });
400
+ prevValue = inputEvent.prevValue;
401
+
402
+ if ((0, _utils.isValidDateValue)(currentElement(), textToBeTyped)) {
403
+ _dom.fireEvent.change(currentElement(), {
404
+ target: {
405
+ value: textToBeTyped
406
+ }
407
+ });
408
+ }
409
+
410
+ fireChangeForInputTimeIfValid(currentElement, prevValue, timeNewEntry); // typing "-" into a number input will not actually update the value
411
+ // so for the next character we type, the value should be set to
412
+ // `-${newEntry}`
413
+ // we also preserve the prevWasMinus when the value is unchanged due
414
+ // to typing an invalid character (typing "-a3" results in "-3")
415
+ // same applies for the decimal character.
416
+
417
+ if (currentElement().type === 'number') {
418
+ const newValue = (0, _utils.getValue)(currentElement());
419
+
420
+ if (newValue === prevValue && newEntry !== '-') {
421
+ nextPrevWasMinus = prevWasMinus;
422
+ } else {
423
+ nextPrevWasMinus = newEntry === '-';
424
+ }
425
+
426
+ if (newValue === prevValue && newEntry !== '.') {
427
+ nextPrevWasPeriod = prevWasPeriod;
428
+ } else {
429
+ nextPrevWasPeriod = newEntry === '.';
430
+ }
431
+ }
432
+ }
433
+ }
434
+
435
+ _dom.fireEvent.keyUp(currentElement(), {
436
+ key,
437
+ keyCode,
438
+ which: keyCode,
439
+ ...eventOverrides
440
+ });
441
+
442
+ return {
443
+ prevWasMinus: nextPrevWasMinus,
444
+ prevWasPeriod: nextPrevWasPeriod,
445
+ prevValue,
446
+ typedValue: textToBeTyped
447
+ };
448
+ }
449
+
450
+ function fireChangeForInputTimeIfValid(currentElement, prevValue, timeNewEntry) {
451
+ if ((0, _utils.isValidInputTimeValue)(currentElement(), timeNewEntry) && prevValue !== timeNewEntry) {
452
+ _dom.fireEvent.change(currentElement(), {
453
+ target: {
454
+ value: timeNewEntry
455
+ }
456
+ });
457
+ }
458
+ } // yes, calculateNewBackspaceValue and calculateNewValue look extremely similar
459
+ // and you may be tempted to create a shared abstraction.
460
+ // If you, brave soul, decide to so endevor, please increment this count
461
+ // when you inevitably fail: 1
462
+
463
+
464
+ function calculateNewBackspaceValue(element) {
465
+ const {
466
+ selectionStart,
467
+ selectionEnd
468
+ } = (0, _utils.getSelectionRange)(element);
469
+ const value = (0, _utils.getValue)(element);
470
+ let newValue, newSelectionStart;
471
+
472
+ if (selectionStart === null) {
473
+ // at the end of an input type that does not support selection ranges
474
+ // https://github.com/testing-library/user-event/issues/316#issuecomment-639744793
475
+ newValue = value.slice(0, value.length - 1);
476
+ newSelectionStart = selectionStart - 1;
477
+ } else if (selectionStart === selectionEnd) {
478
+ if (selectionStart === 0) {
479
+ // at the beginning of the input
480
+ newValue = value;
481
+ newSelectionStart = selectionStart;
482
+ } else if (selectionStart === value.length) {
483
+ // at the end of the input
484
+ newValue = value.slice(0, value.length - 1);
485
+ newSelectionStart = selectionStart - 1;
486
+ } else {
487
+ // in the middle of the input
488
+ newValue = value.slice(0, selectionStart - 1) + value.slice(selectionEnd);
489
+ newSelectionStart = selectionStart - 1;
490
+ }
491
+ } else {
492
+ // we have something selected
493
+ const firstPart = value.slice(0, selectionStart);
494
+ newValue = firstPart + value.slice(selectionEnd);
495
+ newSelectionStart = firstPart.length;
496
+ }
497
+
498
+ return {
499
+ newValue,
500
+ newSelectionStart
501
+ };
502
+ }
503
+
504
+ function calculateNewDeleteValue(element) {
505
+ const {
506
+ selectionStart,
507
+ selectionEnd
508
+ } = (0, _utils.getSelectionRange)(element);
509
+ const value = (0, _utils.getValue)(element);
510
+ let newValue;
511
+
512
+ if (selectionStart === null) {
513
+ // at the end of an input type that does not support selection ranges
514
+ // https://github.com/testing-library/user-event/issues/316#issuecomment-639744793
515
+ newValue = value;
516
+ } else if (selectionStart === selectionEnd) {
517
+ if (selectionStart === 0) {
518
+ // at the beginning of the input
519
+ newValue = value.slice(1);
520
+ } else if (selectionStart === value.length) {
521
+ // at the end of the input
522
+ newValue = value;
523
+ } else {
524
+ // in the middle of the input
525
+ newValue = value.slice(0, selectionStart) + value.slice(selectionEnd + 1);
526
+ }
527
+ } else {
528
+ // we have something selected
529
+ const firstPart = value.slice(0, selectionStart);
530
+ newValue = firstPart + value.slice(selectionEnd);
531
+ }
532
+
533
+ return {
534
+ newValue,
535
+ newSelectionStart: selectionStart
536
+ };
537
+ }
538
+
539
+ function createModifierCallbackEntries({
540
+ name,
541
+ key,
542
+ keyCode,
543
+ modifierProperty
544
+ }) {
545
+ const closeName = `{/${name}}`;
546
+
547
+ function open({
548
+ currentElement,
549
+ eventOverrides
550
+ }) {
551
+ const newEventOverrides = {
552
+ [modifierProperty]: true
553
+ };
554
+
555
+ _dom.fireEvent.keyDown(currentElement(), {
556
+ key,
557
+ keyCode,
558
+ which: keyCode,
559
+ ...eventOverrides,
560
+ ...newEventOverrides
561
+ });
562
+
563
+ return {
564
+ eventOverrides: newEventOverrides
565
+ };
566
+ }
567
+
568
+ open.closeName = closeName;
569
+ return {
570
+ [`{${name}}`]: open,
571
+ [closeName]: function ({
572
+ currentElement,
573
+ eventOverrides
574
+ }) {
575
+ const newEventOverrides = {
576
+ [modifierProperty]: false
577
+ };
578
+
579
+ _dom.fireEvent.keyUp(currentElement(), {
580
+ key,
581
+ keyCode,
582
+ which: keyCode,
583
+ ...eventOverrides,
584
+ ...newEventOverrides
585
+ });
586
+
587
+ return {
588
+ eventOverrides: newEventOverrides
589
+ };
590
+ }
591
+ };
592
+ }
593
+
594
+ function handleEnter({
595
+ currentElement,
596
+ eventOverrides
597
+ }) {
598
+ const key = 'Enter';
599
+ const keyCode = 13;
600
+
601
+ const keyDownDefaultNotPrevented = _dom.fireEvent.keyDown(currentElement(), {
602
+ key,
603
+ keyCode,
604
+ which: keyCode,
605
+ ...eventOverrides
606
+ });
607
+
608
+ if (keyDownDefaultNotPrevented) {
609
+ const keyPressDefaultNotPrevented = _dom.fireEvent.keyPress(currentElement(), {
610
+ key,
611
+ keyCode,
612
+ charCode: keyCode,
613
+ ...eventOverrides
614
+ });
615
+
616
+ if (keyPressDefaultNotPrevented) {
617
+ if ((0, _utils.isClickable)(currentElement())) {
618
+ _dom.fireEvent.click(currentElement(), { ...eventOverrides
619
+ });
620
+ }
621
+
622
+ if (currentElement().tagName === 'TEXTAREA') {
623
+ const {
624
+ newValue,
625
+ newSelectionStart
626
+ } = (0, _utils.calculateNewValue)('\n', currentElement());
627
+
628
+ _dom.fireEvent.input(currentElement(), {
629
+ target: {
630
+ value: newValue
631
+ },
632
+ inputType: 'insertLineBreak',
633
+ ...eventOverrides
634
+ });
635
+
636
+ setSelectionRange({
637
+ currentElement,
638
+ newValue,
639
+ newSelectionStart
640
+ });
641
+ }
642
+
643
+ if (currentElement().tagName === 'INPUT' && currentElement().form && (currentElement().form.querySelectorAll('input').length === 1 || currentElement().form.querySelector('input[type="submit"]') || currentElement().form.querySelector('button[type="submit"]'))) {
644
+ _dom.fireEvent.submit(currentElement().form);
645
+ }
646
+ }
647
+ }
648
+
649
+ _dom.fireEvent.keyUp(currentElement(), {
650
+ key,
651
+ keyCode,
652
+ which: keyCode,
653
+ ...eventOverrides
654
+ });
655
+ }
656
+
657
+ function handleEsc({
658
+ currentElement,
659
+ eventOverrides
660
+ }) {
661
+ const key = 'Escape';
662
+ const keyCode = 27;
663
+
664
+ _dom.fireEvent.keyDown(currentElement(), {
665
+ key,
666
+ keyCode,
667
+ which: keyCode,
668
+ ...eventOverrides
669
+ }); // NOTE: Browsers do not fire a keypress on meta key presses
670
+
671
+
672
+ _dom.fireEvent.keyUp(currentElement(), {
673
+ key,
674
+ keyCode,
675
+ which: keyCode,
676
+ ...eventOverrides
677
+ });
678
+ }
679
+
680
+ function handleDel({
681
+ currentElement,
682
+ eventOverrides
683
+ }) {
684
+ const key = 'Delete';
685
+ const keyCode = 46;
686
+
687
+ const keyPressDefaultNotPrevented = _dom.fireEvent.keyDown(currentElement(), {
688
+ key,
689
+ keyCode,
690
+ which: keyCode,
691
+ ...eventOverrides
692
+ });
693
+
694
+ if (keyPressDefaultNotPrevented) {
695
+ fireInputEventIfNeeded({ ...calculateNewDeleteValue(currentElement()),
696
+ eventOverrides: {
697
+ inputType: 'deleteContentForward',
698
+ ...eventOverrides
699
+ },
700
+ currentElement
701
+ });
702
+ }
703
+
704
+ _dom.fireEvent.keyUp(currentElement(), {
705
+ key,
706
+ keyCode,
707
+ which: keyCode,
708
+ ...eventOverrides
709
+ });
710
+ }
711
+
712
+ function handleBackspace({
713
+ currentElement,
714
+ eventOverrides
715
+ }) {
716
+ const key = 'Backspace';
717
+ const keyCode = 8;
718
+
719
+ const keyPressDefaultNotPrevented = _dom.fireEvent.keyDown(currentElement(), {
720
+ key,
721
+ keyCode,
722
+ which: keyCode,
723
+ ...eventOverrides
724
+ });
725
+
726
+ if (keyPressDefaultNotPrevented) {
727
+ fireInputEventIfNeeded({ ...calculateNewBackspaceValue(currentElement()),
728
+ eventOverrides: {
729
+ inputType: 'deleteContentBackward',
730
+ ...eventOverrides
731
+ },
732
+ currentElement
733
+ });
734
+ }
735
+
736
+ _dom.fireEvent.keyUp(currentElement(), {
737
+ key,
738
+ keyCode,
739
+ which: keyCode,
740
+ ...eventOverrides
741
+ });
742
+ }
743
+
744
+ function handleSelectall({
745
+ currentElement
746
+ }) {
747
+ currentElement().setSelectionRange(0, (0, _utils.getValue)(currentElement()).length);
748
+ }
749
+
750
+ function handleSpace(context) {
751
+ if ((0, _utils.isClickable)(context.currentElement())) {
752
+ handleSpaceOnClickable(context);
753
+ return;
754
+ }
755
+
756
+ typeCharacter(' ', context);
757
+ }
758
+
759
+ function handleSpaceOnClickable({
760
+ currentElement,
761
+ eventOverrides
762
+ }) {
763
+ const key = ' ';
764
+ const keyCode = 32;
765
+
766
+ const keyDownDefaultNotPrevented = _dom.fireEvent.keyDown(currentElement(), {
767
+ key,
768
+ keyCode,
769
+ which: keyCode,
770
+ ...eventOverrides
771
+ });
772
+
773
+ if (keyDownDefaultNotPrevented) {
774
+ _dom.fireEvent.keyPress(currentElement(), {
775
+ key,
776
+ keyCode,
777
+ charCode: keyCode,
778
+ ...eventOverrides
779
+ });
780
+ }
781
+
782
+ const keyUpDefaultNotPrevented = _dom.fireEvent.keyUp(currentElement(), {
783
+ key,
784
+ keyCode,
785
+ which: keyCode,
786
+ ...eventOverrides
787
+ });
788
+
789
+ if (keyDownDefaultNotPrevented && keyUpDefaultNotPrevented) {
790
+ _dom.fireEvent.click(currentElement(), { ...eventOverrides
791
+ });
792
+ }
793
+ }
794
+
795
+ function handleArrowDown({
796
+ currentElement,
797
+ eventOverrides
798
+ }) {
799
+ const key = 'ArrowDown';
800
+ const keyCode = 40;
801
+
802
+ _dom.fireEvent.keyDown(currentElement(), {
803
+ key,
804
+ keyCode,
805
+ which: keyCode,
806
+ ...eventOverrides
807
+ });
808
+
809
+ _dom.fireEvent.keyUp(currentElement(), {
810
+ key,
811
+ keyCode,
812
+ which: keyCode,
813
+ ...eventOverrides
814
+ });
815
+ }
816
+
817
+ function handleArrowUp({
818
+ currentElement,
819
+ eventOverrides
820
+ }) {
821
+ const key = 'ArrowUp';
822
+ const keyCode = 38;
823
+
824
+ _dom.fireEvent.keyDown(currentElement(), {
825
+ key,
826
+ keyCode,
827
+ which: keyCode,
828
+ ...eventOverrides
829
+ });
830
+
831
+ _dom.fireEvent.keyUp(currentElement(), {
832
+ key,
833
+ keyCode,
834
+ which: keyCode,
835
+ ...eventOverrides
836
+ });
837
+ }