@testing-library/user-event 13.0.10 → 13.0.14
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/clear.js +7 -9
- package/dist/click.js +5 -7
- package/dist/keyboard/plugins/arrow.js +3 -3
- package/dist/keyboard/plugins/character.js +51 -34
- package/dist/keyboard/plugins/control.js +14 -10
- package/dist/keyboard/plugins/functional.js +7 -13
- package/dist/keyboard/plugins/index.js +5 -4
- package/dist/keyboard/shared/carryValue.d.ts +2 -0
- package/dist/keyboard/shared/carryValue.js +13 -0
- package/dist/keyboard/shared/{fireInputEventIfNeeded.d.ts → fireInputEvent.d.ts} +2 -5
- package/dist/keyboard/shared/fireInputEvent.js +59 -0
- package/dist/keyboard/shared/index.d.ts +2 -2
- package/dist/keyboard/shared/index.js +12 -12
- package/dist/paste.js +22 -19
- package/dist/select-options.js +1 -1
- package/dist/type/typeImplementation.js +3 -15
- package/dist/upload.js +1 -1
- package/dist/utils/click/isClickableInput.js +2 -2
- package/dist/utils/edit/calculateNewValue.d.ts +2 -2
- package/dist/utils/edit/calculateNewValue.js +21 -73
- package/dist/utils/edit/cursorPosition.d.ts +2 -0
- package/dist/utils/edit/cursorPosition.js +35 -0
- package/dist/utils/edit/hasUnreliableEmptyValue.d.ts +10 -0
- package/dist/utils/edit/hasUnreliableEmptyValue.js +21 -0
- package/dist/utils/edit/isContentEditable.d.ts +3 -1
- package/dist/utils/edit/isEditable.d.ts +24 -0
- package/dist/utils/edit/isEditable.js +40 -0
- package/dist/utils/edit/maxLength.d.ts +1 -0
- package/dist/utils/edit/maxLength.js +50 -0
- package/dist/utils/edit/selectionRange.d.ts +16 -0
- package/dist/utils/edit/selectionRange.js +99 -0
- package/dist/utils/index.d.ts +6 -3
- package/dist/utils/index.js +51 -12
- package/dist/utils/misc/isElementType.d.ts +5 -0
- package/dist/utils/misc/isElementType.js +24 -0
- package/dist/utils/misc/isLabelWithInternallyDisabledControl.js +2 -2
- package/package.json +1 -1
- package/dist/keyboard/plugins/control/calculateNewDeleteValue.d.ts +0 -4
- package/dist/keyboard/plugins/control/calculateNewDeleteValue.js +0 -46
- package/dist/keyboard/plugins/functional/calculateBackspaceValue.d.ts +0 -4
- package/dist/keyboard/plugins/functional/calculateBackspaceValue.js +0 -57
- package/dist/keyboard/shared/fireInputEventIfNeeded.js +0 -58
- package/dist/keyboard/shared/setSelectionRange.d.ts +0 -5
- package/dist/keyboard/shared/setSelectionRange.js +0 -32
- package/dist/utils/edit/getSelectionRange.d.ts +0 -4
- package/dist/utils/edit/getSelectionRange.js +0 -32
- package/dist/utils/edit/setSelectionRangeIfNecessary.d.ts +0 -1
- package/dist/utils/edit/setSelectionRangeIfNecessary.js +0 -44
- package/dist/utils/misc/isInstanceOfElement.d.ts +0 -7
- package/dist/utils/misc/isInstanceOfElement.js +0 -38
package/dist/clear.js
CHANGED
|
@@ -10,22 +10,20 @@ var _utils = require("./utils");
|
|
|
10
10
|
var _type = require("./type");
|
|
11
11
|
|
|
12
12
|
function clear(element) {
|
|
13
|
-
var
|
|
13
|
+
var _element$selectionSta, _element$selectionEnd;
|
|
14
14
|
|
|
15
|
-
if (!(0, _utils.
|
|
15
|
+
if (!(0, _utils.isElementType)(element, ['input', 'textarea'])) {
|
|
16
16
|
// TODO: support contenteditable
|
|
17
17
|
throw new Error('clear currently only supports input and textarea elements.');
|
|
18
18
|
}
|
|
19
19
|
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
if ((0, _utils.isDisabled)(el)) {
|
|
20
|
+
if ((0, _utils.isDisabled)(element)) {
|
|
23
21
|
return;
|
|
24
22
|
} // TODO: track the selection range ourselves so we don't have to do this input "type" trickery
|
|
25
23
|
// just like cypress does: https://github.com/cypress-io/cypress/blob/8d7f1a0bedc3c45a2ebf1ff50324b34129fdc683/packages/driver/src/dom/selection.ts#L16-L37
|
|
26
24
|
|
|
27
25
|
|
|
28
|
-
const elementType =
|
|
26
|
+
const elementType = element.type;
|
|
29
27
|
|
|
30
28
|
if (elementType !== 'textarea') {
|
|
31
29
|
// setSelectionRange is not supported on certain types of inputs, e.g. "number" or "email"
|
|
@@ -35,16 +33,16 @@ function clear(element) {
|
|
|
35
33
|
|
|
36
34
|
(0, _type.type)(element, '{selectall}{del}', {
|
|
37
35
|
delay: 0,
|
|
38
|
-
initialSelectionStart: (
|
|
36
|
+
initialSelectionStart: (_element$selectionSta = element.selectionStart) != null ? _element$selectionSta :
|
|
39
37
|
/* istanbul ignore next */
|
|
40
38
|
undefined,
|
|
41
|
-
initialSelectionEnd: (
|
|
39
|
+
initialSelectionEnd: (_element$selectionEnd = element.selectionEnd) != null ? _element$selectionEnd :
|
|
42
40
|
/* istanbul ignore next */
|
|
43
41
|
undefined
|
|
44
42
|
});
|
|
45
43
|
|
|
46
44
|
if (elementType !== 'textarea') {
|
|
47
45
|
;
|
|
48
|
-
|
|
46
|
+
element.type = elementType;
|
|
49
47
|
}
|
|
50
48
|
}
|
package/dist/click.js
CHANGED
|
@@ -114,19 +114,17 @@ function click(element, init, {
|
|
|
114
114
|
} = {}) {
|
|
115
115
|
if (!skipHover) (0, _hover.hover)(element, init);
|
|
116
116
|
|
|
117
|
-
if ((0, _utils.
|
|
117
|
+
if ((0, _utils.isElementType)(element, 'label')) {
|
|
118
118
|
clickLabel(element, init, {
|
|
119
119
|
clickCount
|
|
120
120
|
});
|
|
121
|
-
} else if ((0, _utils.
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
if (el.type === 'checkbox' || el.type === 'radio') {
|
|
125
|
-
clickBooleanElement(el, init, {
|
|
121
|
+
} else if ((0, _utils.isElementType)(element, 'input')) {
|
|
122
|
+
if (element.type === 'checkbox' || element.type === 'radio') {
|
|
123
|
+
clickBooleanElement(element, init, {
|
|
126
124
|
clickCount
|
|
127
125
|
});
|
|
128
126
|
} else {
|
|
129
|
-
clickElement(
|
|
127
|
+
clickElement(element, init, {
|
|
130
128
|
clickCount
|
|
131
129
|
});
|
|
132
130
|
}
|
|
@@ -13,21 +13,21 @@ var _utils = require("../../utils");
|
|
|
13
13
|
*/
|
|
14
14
|
const keydownBehavior = [{
|
|
15
15
|
// TODO: implement for textarea and contentEditable
|
|
16
|
-
matches: (keyDef, element) => (keyDef.key === 'ArrowLeft' || keyDef.key === 'ArrowRight') && (0, _utils.
|
|
16
|
+
matches: (keyDef, element) => (keyDef.key === 'ArrowLeft' || keyDef.key === 'ArrowRight') && (0, _utils.isElementType)(element, 'input'),
|
|
17
17
|
handle: (keyDef, element) => {
|
|
18
18
|
var _ref;
|
|
19
19
|
|
|
20
20
|
const {
|
|
21
21
|
selectionStart,
|
|
22
22
|
selectionEnd
|
|
23
|
-
} = element;
|
|
23
|
+
} = (0, _utils.getSelectionRange)(element);
|
|
24
24
|
const direction = keyDef.key === 'ArrowLeft' ? -1 : 1;
|
|
25
25
|
const newPos = (_ref = selectionStart === selectionEnd ? (selectionStart != null ? selectionStart :
|
|
26
26
|
/* istanbul ignore next */
|
|
27
27
|
0) + direction : direction < 0 ? selectionStart : selectionEnd) != null ? _ref :
|
|
28
28
|
/* istanbul ignore next */
|
|
29
29
|
0;
|
|
30
|
-
(0, _utils.
|
|
30
|
+
(0, _utils.setSelectionRange)(element, newPos, newPos);
|
|
31
31
|
}
|
|
32
32
|
}];
|
|
33
33
|
exports.keydownBehavior = keydownBehavior;
|
|
@@ -18,7 +18,10 @@ const keypressBehavior = [{
|
|
|
18
18
|
matches: (keyDef, element) => {
|
|
19
19
|
var _keyDef$key;
|
|
20
20
|
|
|
21
|
-
return ((_keyDef$key = keyDef.key) == null ? void 0 : _keyDef$key.length) === 1 && (0, _utils.
|
|
21
|
+
return ((_keyDef$key = keyDef.key) == null ? void 0 : _keyDef$key.length) === 1 && (0, _utils.isElementType)(element, 'input', {
|
|
22
|
+
type: 'time',
|
|
23
|
+
readOnly: false
|
|
24
|
+
});
|
|
22
25
|
},
|
|
23
26
|
handle: (keyDef, element, options, state) => {
|
|
24
27
|
var _state$carryValue;
|
|
@@ -35,17 +38,20 @@ const keypressBehavior = [{
|
|
|
35
38
|
newValue,
|
|
36
39
|
newSelectionStart
|
|
37
40
|
} = (0, _utils.calculateNewValue)(newEntry, element);
|
|
38
|
-
const
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
41
|
+
const prevValue = (0, _utils.getValue)(element); // this check was provided by fireInputEventIfNeeded
|
|
42
|
+
// TODO: verify if it is even needed by this handler
|
|
43
|
+
|
|
44
|
+
if (prevValue !== newValue) {
|
|
45
|
+
(0, _shared.fireInputEvent)(element, {
|
|
46
|
+
newValue,
|
|
47
|
+
newSelectionStart,
|
|
48
|
+
eventOverrides: {
|
|
49
|
+
data: keyDef.key,
|
|
50
|
+
inputType: 'insertText'
|
|
51
|
+
}
|
|
52
|
+
});
|
|
53
|
+
}
|
|
54
|
+
|
|
49
55
|
(0, _shared.fireChangeForInputTimeIfValid)(element, prevValue, timeNewEntry);
|
|
50
56
|
state.carryValue = textToBeTyped;
|
|
51
57
|
}
|
|
@@ -53,7 +59,10 @@ const keypressBehavior = [{
|
|
|
53
59
|
matches: (keyDef, element) => {
|
|
54
60
|
var _keyDef$key2;
|
|
55
61
|
|
|
56
|
-
return ((_keyDef$key2 = keyDef.key) == null ? void 0 : _keyDef$key2.length) === 1 && (0, _utils.
|
|
62
|
+
return ((_keyDef$key2 = keyDef.key) == null ? void 0 : _keyDef$key2.length) === 1 && (0, _utils.isElementType)(element, 'input', {
|
|
63
|
+
type: 'date',
|
|
64
|
+
readOnly: false
|
|
65
|
+
});
|
|
57
66
|
},
|
|
58
67
|
handle: (keyDef, element, options, state) => {
|
|
59
68
|
var _state$carryValue2;
|
|
@@ -70,15 +79,19 @@ const keypressBehavior = [{
|
|
|
70
79
|
newValue,
|
|
71
80
|
newSelectionStart
|
|
72
81
|
} = (0, _utils.calculateNewValue)(newEntry, element);
|
|
73
|
-
(0,
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
+
const prevValue = (0, _utils.getValue)(element); // this check was provided by fireInputEventIfNeeded
|
|
83
|
+
// TODO: verify if it is even needed by this handler
|
|
84
|
+
|
|
85
|
+
if (prevValue !== newValue) {
|
|
86
|
+
(0, _shared.fireInputEvent)(element, {
|
|
87
|
+
newValue,
|
|
88
|
+
newSelectionStart,
|
|
89
|
+
eventOverrides: {
|
|
90
|
+
data: keyDef.key,
|
|
91
|
+
inputType: 'insertText'
|
|
92
|
+
}
|
|
93
|
+
});
|
|
94
|
+
}
|
|
82
95
|
|
|
83
96
|
if (isValidToBeTyped) {
|
|
84
97
|
_dom.fireEvent.change(element, {
|
|
@@ -94,7 +107,10 @@ const keypressBehavior = [{
|
|
|
94
107
|
matches: (keyDef, element) => {
|
|
95
108
|
var _keyDef$key3;
|
|
96
109
|
|
|
97
|
-
return ((_keyDef$key3 = keyDef.key) == null ? void 0 : _keyDef$key3.length) === 1 && (0, _utils.
|
|
110
|
+
return ((_keyDef$key3 = keyDef.key) == null ? void 0 : _keyDef$key3.length) === 1 && (0, _utils.isElementType)(element, 'input', {
|
|
111
|
+
type: 'number',
|
|
112
|
+
readOnly: false
|
|
113
|
+
});
|
|
98
114
|
},
|
|
99
115
|
handle: (keyDef, element, options, state) => {
|
|
100
116
|
var _ref, _state$carryValue3;
|
|
@@ -110,14 +126,13 @@ const keypressBehavior = [{
|
|
|
110
126
|
newValue,
|
|
111
127
|
newSelectionStart
|
|
112
128
|
} = (0, _utils.calculateNewValue)(keyDef.key, element, oldValue);
|
|
113
|
-
(0, _shared.
|
|
129
|
+
(0, _shared.fireInputEvent)(element, {
|
|
114
130
|
newValue,
|
|
115
131
|
newSelectionStart,
|
|
116
132
|
eventOverrides: {
|
|
117
133
|
data: keyDef.key,
|
|
118
134
|
inputType: 'insertText'
|
|
119
|
-
}
|
|
120
|
-
currentElement: () => element
|
|
135
|
+
}
|
|
121
136
|
});
|
|
122
137
|
const appliedValue = (0, _utils.getValue)(element);
|
|
123
138
|
|
|
@@ -131,38 +146,40 @@ const keypressBehavior = [{
|
|
|
131
146
|
matches: (keyDef, element) => {
|
|
132
147
|
var _keyDef$key4;
|
|
133
148
|
|
|
134
|
-
return ((_keyDef$key4 = keyDef.key) == null ? void 0 : _keyDef$key4.length) === 1 && ((0, _utils.
|
|
149
|
+
return ((_keyDef$key4 = keyDef.key) == null ? void 0 : _keyDef$key4.length) === 1 && ((0, _utils.isElementType)(element, ['input', 'textarea'], {
|
|
150
|
+
readOnly: false
|
|
151
|
+
}) && !(0, _utils.isClickableInput)(element) || (0, _utils.isContentEditable)(element)) && (0, _utils.getSpaceUntilMaxLength)(element) !== 0;
|
|
135
152
|
},
|
|
136
153
|
handle: (keyDef, element) => {
|
|
137
154
|
const {
|
|
138
155
|
newValue,
|
|
139
156
|
newSelectionStart
|
|
140
157
|
} = (0, _utils.calculateNewValue)(keyDef.key, element);
|
|
141
|
-
(0, _shared.
|
|
158
|
+
(0, _shared.fireInputEvent)(element, {
|
|
142
159
|
newValue,
|
|
143
160
|
newSelectionStart,
|
|
144
161
|
eventOverrides: {
|
|
145
162
|
data: keyDef.key,
|
|
146
163
|
inputType: 'insertText'
|
|
147
|
-
}
|
|
148
|
-
currentElement: () => element
|
|
164
|
+
}
|
|
149
165
|
});
|
|
150
166
|
}
|
|
151
167
|
}, {
|
|
152
|
-
matches: (keyDef, element) => keyDef.key === 'Enter' && ((0, _utils.
|
|
168
|
+
matches: (keyDef, element) => keyDef.key === 'Enter' && ((0, _utils.isElementType)(element, 'textarea', {
|
|
169
|
+
readOnly: false
|
|
170
|
+
}) || (0, _utils.isContentEditable)(element)) && (0, _utils.getSpaceUntilMaxLength)(element) !== 0,
|
|
153
171
|
handle: (keyDef, element, options, state) => {
|
|
154
172
|
const {
|
|
155
173
|
newValue,
|
|
156
174
|
newSelectionStart
|
|
157
175
|
} = (0, _utils.calculateNewValue)('\n', element);
|
|
158
176
|
const inputType = (0, _utils.isContentEditable)(element) && !state.modifiers.shift ? 'insertParagraph' : 'insertLineBreak';
|
|
159
|
-
(0, _shared.
|
|
177
|
+
(0, _shared.fireInputEvent)(element, {
|
|
160
178
|
newValue,
|
|
161
179
|
newSelectionStart,
|
|
162
180
|
eventOverrides: {
|
|
163
181
|
inputType
|
|
164
|
-
}
|
|
165
|
-
currentElement: () => element
|
|
182
|
+
}
|
|
166
183
|
});
|
|
167
184
|
}
|
|
168
185
|
}];
|
|
@@ -9,36 +9,40 @@ var _utils = require("../../utils");
|
|
|
9
9
|
|
|
10
10
|
var _shared = require("../shared");
|
|
11
11
|
|
|
12
|
-
var _calculateNewDeleteValue = require("./control/calculateNewDeleteValue");
|
|
13
|
-
|
|
14
12
|
/**
|
|
15
13
|
* This file should contain behavior for arrow keys as described here:
|
|
16
14
|
* https://w3c.github.io/uievents-code/#key-controlpad-section
|
|
17
15
|
*/
|
|
18
16
|
const keydownBehavior = [{
|
|
19
|
-
matches: (keyDef, element) => (keyDef.key === 'Home' || keyDef.key === 'End') && ((0, _utils.
|
|
17
|
+
matches: (keyDef, element) => (keyDef.key === 'Home' || keyDef.key === 'End') && ((0, _utils.isElementType)(element, ['input', 'textarea']) || (0, _utils.isContentEditable)(element)),
|
|
20
18
|
handle: (keyDef, element) => {
|
|
21
19
|
// This could probably been improved by collapsing a selection range
|
|
22
20
|
if (keyDef.key === 'Home') {
|
|
23
|
-
(0, _utils.
|
|
21
|
+
(0, _utils.setSelectionRange)(element, 0, 0);
|
|
24
22
|
} else {
|
|
25
23
|
var _getValue$length, _getValue;
|
|
26
24
|
|
|
27
25
|
const newPos = (_getValue$length = (_getValue = (0, _utils.getValue)(element)) == null ? void 0 : _getValue.length) != null ? _getValue$length :
|
|
28
26
|
/* istanbul ignore next */
|
|
29
27
|
0;
|
|
30
|
-
(0, _utils.
|
|
28
|
+
(0, _utils.setSelectionRange)(element, newPos, newPos);
|
|
31
29
|
}
|
|
32
30
|
}
|
|
33
31
|
}, {
|
|
34
|
-
matches: keyDef => keyDef.key === 'Delete',
|
|
35
|
-
handle: (keDef, element) => {
|
|
36
|
-
|
|
32
|
+
matches: (keyDef, element) => keyDef.key === 'Delete' && (0, _utils.isEditable)(element) && !(0, _utils.isCursorAtEnd)(element),
|
|
33
|
+
handle: (keDef, element, options, state) => {
|
|
34
|
+
const {
|
|
35
|
+
newValue,
|
|
36
|
+
newSelectionStart
|
|
37
|
+
} = (0, _utils.calculateNewValue)('', element, state.carryValue, undefined, 'forward');
|
|
38
|
+
(0, _shared.fireInputEvent)(element, {
|
|
39
|
+
newValue,
|
|
40
|
+
newSelectionStart,
|
|
37
41
|
eventOverrides: {
|
|
38
42
|
inputType: 'deleteContentForward'
|
|
39
|
-
}
|
|
40
|
-
currentElement: () => element
|
|
43
|
+
}
|
|
41
44
|
});
|
|
45
|
+
(0, _shared.carryValue)(element, state, newValue);
|
|
42
46
|
}
|
|
43
47
|
}];
|
|
44
48
|
exports.keydownBehavior = keydownBehavior;
|
|
@@ -13,8 +13,6 @@ var _getEventProps = require("../getEventProps");
|
|
|
13
13
|
|
|
14
14
|
var _shared = require("../shared");
|
|
15
15
|
|
|
16
|
-
var _calculateBackspaceValue = require("./functional/calculateBackspaceValue");
|
|
17
|
-
|
|
18
16
|
/**
|
|
19
17
|
* This file should contain behavior for functional keys as described here:
|
|
20
18
|
* https://w3c.github.io/uievents-code/#key-alphanumeric-functional
|
|
@@ -55,35 +53,31 @@ const keydownBehavior = [{
|
|
|
55
53
|
state.modifiers.caps = !state.modifiers.caps;
|
|
56
54
|
}
|
|
57
55
|
}, {
|
|
58
|
-
matches: keyDef => keyDef.key === 'Backspace',
|
|
56
|
+
matches: (keyDef, element) => keyDef.key === 'Backspace' && (0, _utils.isEditable)(element) && !(0, _utils.isCursorAtStart)(element),
|
|
59
57
|
handle: (keyDef, element, options, state) => {
|
|
60
58
|
const {
|
|
61
59
|
newValue,
|
|
62
60
|
newSelectionStart
|
|
63
|
-
} = (0,
|
|
64
|
-
(0, _shared.
|
|
61
|
+
} = (0, _utils.calculateNewValue)('', element, state.carryValue, undefined, 'backward');
|
|
62
|
+
(0, _shared.fireInputEvent)(element, {
|
|
65
63
|
newValue,
|
|
66
64
|
newSelectionStart,
|
|
67
65
|
eventOverrides: {
|
|
68
66
|
inputType: 'deleteContentBackward'
|
|
69
|
-
}
|
|
70
|
-
currentElement: () => element
|
|
67
|
+
}
|
|
71
68
|
});
|
|
72
|
-
|
|
73
|
-
if (state.carryValue) {
|
|
74
|
-
state.carryValue = (0, _utils.getValue)(element) === newValue ? undefined : newValue;
|
|
75
|
-
}
|
|
69
|
+
(0, _shared.carryValue)(element, state, newValue);
|
|
76
70
|
}
|
|
77
71
|
}];
|
|
78
72
|
exports.keydownBehavior = keydownBehavior;
|
|
79
73
|
const keypressBehavior = [{
|
|
80
74
|
matches: (keyDef, element) => keyDef.key === 'Enter' && ((0, _utils.isClickableInput)(element) || // Links with href defined should handle Enter the same as a click
|
|
81
|
-
(0, _utils.
|
|
75
|
+
(0, _utils.isElementType)(element, 'a') && Boolean(element.href)),
|
|
82
76
|
handle: (keyDef, element, options, state) => {
|
|
83
77
|
_dom.fireEvent.click(element, (0, _getEventProps.getMouseEventProps)(state));
|
|
84
78
|
}
|
|
85
79
|
}, {
|
|
86
|
-
matches: (keyDef, element) => keyDef.key === 'Enter' && (0, _utils.
|
|
80
|
+
matches: (keyDef, element) => keyDef.key === 'Enter' && (0, _utils.isElementType)(element, 'input'),
|
|
87
81
|
handle: (keyDef, element) => {
|
|
88
82
|
const form = element.form;
|
|
89
83
|
|
|
@@ -18,10 +18,11 @@ var characterKeys = _interopRequireWildcard(require("./character"));
|
|
|
18
18
|
var functionalKeys = _interopRequireWildcard(require("./functional"));
|
|
19
19
|
|
|
20
20
|
const replaceBehavior = [{
|
|
21
|
-
matches: (keyDef, element) => keyDef.key === 'selectall' && (
|
|
22
|
-
handle: (keyDef, element) => {
|
|
23
|
-
;
|
|
24
|
-
|
|
21
|
+
matches: (keyDef, element) => keyDef.key === 'selectall' && (0, _utils.isElementType)(element, ['input', 'textarea']),
|
|
22
|
+
handle: (keyDef, element, options, state) => {
|
|
23
|
+
var _state$carryValue;
|
|
24
|
+
|
|
25
|
+
(0, _utils.setSelectionRange)(element, 0, ((_state$carryValue = state.carryValue) != null ? _state$carryValue : element.value).length);
|
|
25
26
|
}
|
|
26
27
|
}];
|
|
27
28
|
exports.replaceBehavior = replaceBehavior;
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
|
|
3
|
+
Object.defineProperty(exports, "__esModule", {
|
|
4
|
+
value: true
|
|
5
|
+
});
|
|
6
|
+
exports.carryValue = carryValue;
|
|
7
|
+
|
|
8
|
+
var _utils = require("../../utils");
|
|
9
|
+
|
|
10
|
+
function carryValue(element, state, newValue) {
|
|
11
|
+
const value = (0, _utils.getValue)(element);
|
|
12
|
+
state.carryValue = value !== newValue && value === '' && (0, _utils.hasUnreliableEmptyValue)(element) ? newValue : undefined;
|
|
13
|
+
}
|
|
@@ -1,11 +1,8 @@
|
|
|
1
1
|
import { fireEvent } from '@testing-library/dom';
|
|
2
|
-
export declare function
|
|
3
|
-
currentElement: () => Element | null;
|
|
2
|
+
export declare function fireInputEvent(element: HTMLElement, { newValue, newSelectionStart, eventOverrides, }: {
|
|
4
3
|
newValue: string;
|
|
5
4
|
newSelectionStart: number;
|
|
6
5
|
eventOverrides: Partial<Parameters<typeof fireEvent>[1]> & {
|
|
7
6
|
[k: string]: unknown;
|
|
8
7
|
};
|
|
9
|
-
}):
|
|
10
|
-
prevValue: string | null;
|
|
11
|
-
};
|
|
8
|
+
}): void;
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
|
|
3
|
+
Object.defineProperty(exports, "__esModule", {
|
|
4
|
+
value: true
|
|
5
|
+
});
|
|
6
|
+
exports.fireInputEvent = fireInputEvent;
|
|
7
|
+
|
|
8
|
+
var _dom = require("@testing-library/dom");
|
|
9
|
+
|
|
10
|
+
var _utils = require("../../utils");
|
|
11
|
+
|
|
12
|
+
function fireInputEvent(element, {
|
|
13
|
+
newValue,
|
|
14
|
+
newSelectionStart,
|
|
15
|
+
eventOverrides
|
|
16
|
+
}) {
|
|
17
|
+
// apply the changes before firing the input event, so that input handlers can access the altered dom and selection
|
|
18
|
+
if ((0, _utils.isContentEditable)(element)) {
|
|
19
|
+
element.textContent = newValue;
|
|
20
|
+
} else
|
|
21
|
+
/* istanbul ignore else */
|
|
22
|
+
if ((0, _utils.isElementType)(element, ['input', 'textarea'])) {
|
|
23
|
+
element.value = newValue;
|
|
24
|
+
} else {
|
|
25
|
+
// TODO: properly type guard
|
|
26
|
+
throw new Error('Invalid Element');
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
setSelectionRangeAfterInput(element, newSelectionStart);
|
|
30
|
+
|
|
31
|
+
_dom.fireEvent.input(element, { ...eventOverrides
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
setSelectionRangeAfterInputHandler(element, newValue);
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
function setSelectionRangeAfterInput(element, newSelectionStart) {
|
|
38
|
+
(0, _utils.setSelectionRange)(element, newSelectionStart, newSelectionStart);
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
function setSelectionRangeAfterInputHandler(element, newValue) {
|
|
42
|
+
// if we *can* change the selection start, then we will if the new value
|
|
43
|
+
// is the same as the current value (so it wasn't programatically changed
|
|
44
|
+
// when the fireEvent.input was triggered).
|
|
45
|
+
// The reason we have to do this at all is because it actually *is*
|
|
46
|
+
// programmatically changed by fireEvent.input, so we have to simulate the
|
|
47
|
+
// browser's default behavior
|
|
48
|
+
const value = (0, _utils.getValue)(element); // don't apply this workaround on elements that don't necessarily report the visible value - e.g. number
|
|
49
|
+
// TODO: this could probably be only applied when there is keyboardState.carryValue
|
|
50
|
+
|
|
51
|
+
const expectedValue = value === newValue || value === '' && (0, _utils.hasUnreliableEmptyValue)(element);
|
|
52
|
+
|
|
53
|
+
if (!expectedValue) {
|
|
54
|
+
// If the currentValue is different than the expected newValue and we *can*
|
|
55
|
+
// change the selection range, than we should set it to the length of the
|
|
56
|
+
// currentValue to ensure that the browser behavior is mimicked.
|
|
57
|
+
(0, _utils.setSelectionRange)(element, value.length, value.length);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
@@ -4,41 +4,41 @@ Object.defineProperty(exports, "__esModule", {
|
|
|
4
4
|
value: true
|
|
5
5
|
});
|
|
6
6
|
|
|
7
|
-
var
|
|
7
|
+
var _carryValue = require("./carryValue");
|
|
8
8
|
|
|
9
|
-
Object.keys(
|
|
9
|
+
Object.keys(_carryValue).forEach(function (key) {
|
|
10
10
|
if (key === "default" || key === "__esModule") return;
|
|
11
|
-
if (key in exports && exports[key] ===
|
|
11
|
+
if (key in exports && exports[key] === _carryValue[key]) return;
|
|
12
12
|
Object.defineProperty(exports, key, {
|
|
13
13
|
enumerable: true,
|
|
14
14
|
get: function () {
|
|
15
|
-
return
|
|
15
|
+
return _carryValue[key];
|
|
16
16
|
}
|
|
17
17
|
});
|
|
18
18
|
});
|
|
19
19
|
|
|
20
|
-
var
|
|
20
|
+
var _fireChangeForInputTimeIfValid = require("./fireChangeForInputTimeIfValid");
|
|
21
21
|
|
|
22
|
-
Object.keys(
|
|
22
|
+
Object.keys(_fireChangeForInputTimeIfValid).forEach(function (key) {
|
|
23
23
|
if (key === "default" || key === "__esModule") return;
|
|
24
|
-
if (key in exports && exports[key] ===
|
|
24
|
+
if (key in exports && exports[key] === _fireChangeForInputTimeIfValid[key]) return;
|
|
25
25
|
Object.defineProperty(exports, key, {
|
|
26
26
|
enumerable: true,
|
|
27
27
|
get: function () {
|
|
28
|
-
return
|
|
28
|
+
return _fireChangeForInputTimeIfValid[key];
|
|
29
29
|
}
|
|
30
30
|
});
|
|
31
31
|
});
|
|
32
32
|
|
|
33
|
-
var
|
|
33
|
+
var _fireInputEvent = require("./fireInputEvent");
|
|
34
34
|
|
|
35
|
-
Object.keys(
|
|
35
|
+
Object.keys(_fireInputEvent).forEach(function (key) {
|
|
36
36
|
if (key === "default" || key === "__esModule") return;
|
|
37
|
-
if (key in exports && exports[key] ===
|
|
37
|
+
if (key in exports && exports[key] === _fireInputEvent[key]) return;
|
|
38
38
|
Object.defineProperty(exports, key, {
|
|
39
39
|
enumerable: true,
|
|
40
40
|
get: function () {
|
|
41
|
-
return
|
|
41
|
+
return _fireInputEvent[key];
|
|
42
42
|
}
|
|
43
43
|
});
|
|
44
44
|
});
|
package/dist/paste.js
CHANGED
|
@@ -32,28 +32,31 @@ function paste(element, text, init, {
|
|
|
32
32
|
// explicitely start typing with the cursor at 0. Not super common.
|
|
33
33
|
|
|
34
34
|
if (element.selectionStart === 0 && element.selectionEnd === 0) {
|
|
35
|
-
(0, _utils.
|
|
35
|
+
(0, _utils.setSelectionRange)(element, initialSelectionStart != null ? initialSelectionStart : element.value.length, initialSelectionEnd != null ? initialSelectionEnd : element.value.length);
|
|
36
36
|
}
|
|
37
37
|
|
|
38
38
|
_dom.fireEvent.paste(element, init);
|
|
39
39
|
|
|
40
|
-
if (
|
|
41
|
-
|
|
42
|
-
newValue,
|
|
43
|
-
newSelectionStart
|
|
44
|
-
} = (0, _utils.calculateNewValue)(text, element);
|
|
45
|
-
|
|
46
|
-
_dom.fireEvent.input(element, {
|
|
47
|
-
inputType: 'insertFromPaste',
|
|
48
|
-
target: {
|
|
49
|
-
value: newValue
|
|
50
|
-
}
|
|
51
|
-
});
|
|
52
|
-
|
|
53
|
-
(0, _utils.setSelectionRangeIfNecessary)(element, // TODO: investigate why the selection caused by invalid parameters was expected
|
|
54
|
-
{
|
|
55
|
-
newSelectionStart,
|
|
56
|
-
selectionEnd: newSelectionStart
|
|
57
|
-
}, {});
|
|
40
|
+
if (element.readOnly) {
|
|
41
|
+
return;
|
|
58
42
|
}
|
|
43
|
+
|
|
44
|
+
text = text.substr(0, (0, _utils.getSpaceUntilMaxLength)(element));
|
|
45
|
+
const {
|
|
46
|
+
newValue,
|
|
47
|
+
newSelectionStart
|
|
48
|
+
} = (0, _utils.calculateNewValue)(text, element);
|
|
49
|
+
|
|
50
|
+
_dom.fireEvent.input(element, {
|
|
51
|
+
inputType: 'insertFromPaste',
|
|
52
|
+
target: {
|
|
53
|
+
value: newValue
|
|
54
|
+
}
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
(0, _utils.setSelectionRange)(element, // TODO: investigate why the selection caused by invalid parameters was expected
|
|
58
|
+
{
|
|
59
|
+
newSelectionStart,
|
|
60
|
+
selectionEnd: newSelectionStart
|
|
61
|
+
}, {});
|
|
59
62
|
}
|
package/dist/select-options.js
CHANGED
|
@@ -37,7 +37,7 @@ function selectOptionsBase(newValue, select, values, init) {
|
|
|
37
37
|
}).filter(option => !(0, _utils.isDisabled)(option));
|
|
38
38
|
if ((0, _utils.isDisabled)(select) || !selectedOptions.length) return;
|
|
39
39
|
|
|
40
|
-
if ((0, _utils.
|
|
40
|
+
if ((0, _utils.isElementType)(select, 'select')) {
|
|
41
41
|
if (select.multiple) {
|
|
42
42
|
for (const option of selectedOptions) {
|
|
43
43
|
// events fired for multiple select are weird. Can't use hover...
|
|
@@ -21,19 +21,7 @@ async function typeImplementation(element, text, {
|
|
|
21
21
|
// TODO: properly type guard
|
|
22
22
|
// we use this workaround for now to prevent changing behavior
|
|
23
23
|
if (element.disabled) return;
|
|
24
|
-
if (!skipClick) (0, _click.click)(element);
|
|
25
|
-
|
|
26
|
-
if ((0, _utils.isContentEditable)(element)) {
|
|
27
|
-
const selection = document.getSelection(); // istanbul ignore else
|
|
28
|
-
|
|
29
|
-
if (selection && selection.rangeCount === 0) {
|
|
30
|
-
const range = document.createRange();
|
|
31
|
-
range.setStart(element, 0);
|
|
32
|
-
range.setEnd(element, 0);
|
|
33
|
-
selection.addRange(range);
|
|
34
|
-
}
|
|
35
|
-
} // The focused element could change between each event, so get the currently active element each time
|
|
36
|
-
|
|
24
|
+
if (!skipClick) (0, _click.click)(element); // The focused element could change between each event, so get the currently active element each time
|
|
37
25
|
|
|
38
26
|
const currentElement = () => (0, _utils.getActiveElement)(element.ownerDocument); // by default, a new element has it's selection start and end at 0
|
|
39
27
|
// but most of the time when people call "type", they expect it to type
|
|
@@ -51,8 +39,8 @@ async function typeImplementation(element, text, {
|
|
|
51
39
|
selectionEnd
|
|
52
40
|
} = (0, _utils.getSelectionRange)(element);
|
|
53
41
|
|
|
54
|
-
if (value != null && selectionStart === 0 && selectionEnd === 0) {
|
|
55
|
-
(0, _utils.
|
|
42
|
+
if (value != null && (selectionStart === null || selectionStart === 0) && (selectionEnd === null || selectionEnd === 0)) {
|
|
43
|
+
(0, _utils.setSelectionRange)(currentElement(), initialSelectionStart != null ? initialSelectionStart : value.length, initialSelectionEnd != null ? initialSelectionEnd : value.length);
|
|
56
44
|
}
|
|
57
45
|
|
|
58
46
|
const {
|
package/dist/upload.js
CHANGED
|
@@ -22,7 +22,7 @@ function upload(element, fileOrFiles, init, {
|
|
|
22
22
|
|
|
23
23
|
if ((0, _utils.isDisabled)(element)) return;
|
|
24
24
|
(0, _click.click)(element, init == null ? void 0 : init.clickInit);
|
|
25
|
-
const input = (0, _utils.
|
|
25
|
+
const input = (0, _utils.isElementType)(element, 'label') ? element.control : element;
|
|
26
26
|
const files = (Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles]).filter(file => !applyAccept || isAcceptableFile(file, input.accept)).slice(0, input.multiple ? undefined : 1); // blur fires when the file selector pops up
|
|
27
27
|
|
|
28
28
|
(0, _blur.blur)(element); // focus fires when they make their selection
|
|
@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
|
|
|
5
5
|
});
|
|
6
6
|
exports.isClickableInput = isClickableInput;
|
|
7
7
|
|
|
8
|
-
var
|
|
8
|
+
var _isElementType = require("../misc/isElementType");
|
|
9
9
|
|
|
10
10
|
const CLICKABLE_INPUT_TYPES = ['button', 'color', 'file', 'image', 'reset', 'submit'];
|
|
11
11
|
|
|
12
12
|
function isClickableInput(element) {
|
|
13
|
-
return element
|
|
13
|
+
return (0, _isElementType.isElementType)(element, 'button') || (0, _isElementType.isElementType)(element, 'input') && CLICKABLE_INPUT_TYPES.includes(element.type);
|
|
14
14
|
}
|