@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.
Files changed (50) hide show
  1. package/dist/clear.js +7 -9
  2. package/dist/click.js +5 -7
  3. package/dist/keyboard/plugins/arrow.js +3 -3
  4. package/dist/keyboard/plugins/character.js +51 -34
  5. package/dist/keyboard/plugins/control.js +14 -10
  6. package/dist/keyboard/plugins/functional.js +7 -13
  7. package/dist/keyboard/plugins/index.js +5 -4
  8. package/dist/keyboard/shared/carryValue.d.ts +2 -0
  9. package/dist/keyboard/shared/carryValue.js +13 -0
  10. package/dist/keyboard/shared/{fireInputEventIfNeeded.d.ts → fireInputEvent.d.ts} +2 -5
  11. package/dist/keyboard/shared/fireInputEvent.js +59 -0
  12. package/dist/keyboard/shared/index.d.ts +2 -2
  13. package/dist/keyboard/shared/index.js +12 -12
  14. package/dist/paste.js +22 -19
  15. package/dist/select-options.js +1 -1
  16. package/dist/type/typeImplementation.js +3 -15
  17. package/dist/upload.js +1 -1
  18. package/dist/utils/click/isClickableInput.js +2 -2
  19. package/dist/utils/edit/calculateNewValue.d.ts +2 -2
  20. package/dist/utils/edit/calculateNewValue.js +21 -73
  21. package/dist/utils/edit/cursorPosition.d.ts +2 -0
  22. package/dist/utils/edit/cursorPosition.js +35 -0
  23. package/dist/utils/edit/hasUnreliableEmptyValue.d.ts +10 -0
  24. package/dist/utils/edit/hasUnreliableEmptyValue.js +21 -0
  25. package/dist/utils/edit/isContentEditable.d.ts +3 -1
  26. package/dist/utils/edit/isEditable.d.ts +24 -0
  27. package/dist/utils/edit/isEditable.js +40 -0
  28. package/dist/utils/edit/maxLength.d.ts +1 -0
  29. package/dist/utils/edit/maxLength.js +50 -0
  30. package/dist/utils/edit/selectionRange.d.ts +16 -0
  31. package/dist/utils/edit/selectionRange.js +99 -0
  32. package/dist/utils/index.d.ts +6 -3
  33. package/dist/utils/index.js +51 -12
  34. package/dist/utils/misc/isElementType.d.ts +5 -0
  35. package/dist/utils/misc/isElementType.js +24 -0
  36. package/dist/utils/misc/isLabelWithInternallyDisabledControl.js +2 -2
  37. package/package.json +1 -1
  38. package/dist/keyboard/plugins/control/calculateNewDeleteValue.d.ts +0 -4
  39. package/dist/keyboard/plugins/control/calculateNewDeleteValue.js +0 -46
  40. package/dist/keyboard/plugins/functional/calculateBackspaceValue.d.ts +0 -4
  41. package/dist/keyboard/plugins/functional/calculateBackspaceValue.js +0 -57
  42. package/dist/keyboard/shared/fireInputEventIfNeeded.js +0 -58
  43. package/dist/keyboard/shared/setSelectionRange.d.ts +0 -5
  44. package/dist/keyboard/shared/setSelectionRange.js +0 -32
  45. package/dist/utils/edit/getSelectionRange.d.ts +0 -4
  46. package/dist/utils/edit/getSelectionRange.js +0 -32
  47. package/dist/utils/edit/setSelectionRangeIfNecessary.d.ts +0 -1
  48. package/dist/utils/edit/setSelectionRangeIfNecessary.js +0 -44
  49. package/dist/utils/misc/isInstanceOfElement.d.ts +0 -7
  50. 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 _el$selectionStart, _el$selectionEnd;
13
+ var _element$selectionSta, _element$selectionEnd;
14
14
 
15
- if (!(0, _utils.isInstanceOfElement)(element, 'HTMLInputElement') && !(0, _utils.isInstanceOfElement)(element, 'HTMLTextAreaElement')) {
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
- const el = element;
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 = el.type;
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: (_el$selectionStart = el.selectionStart) != null ? _el$selectionStart :
36
+ initialSelectionStart: (_element$selectionSta = element.selectionStart) != null ? _element$selectionSta :
39
37
  /* istanbul ignore next */
40
38
  undefined,
41
- initialSelectionEnd: (_el$selectionEnd = el.selectionEnd) != null ? _el$selectionEnd :
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
- el.type = elementType;
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.isInstanceOfElement)(element, 'HTMLLabelElement')) {
117
+ if ((0, _utils.isElementType)(element, 'label')) {
118
118
  clickLabel(element, init, {
119
119
  clickCount
120
120
  });
121
- } else if ((0, _utils.isInstanceOfElement)(element, 'HTMLInputElement')) {
122
- const el = element;
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(el, init, {
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.isInstanceOfElement)(element, 'HTMLInputElement'),
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.setSelectionRangeIfNecessary)(element, newPos, newPos);
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.isInstanceOfElement)(element, 'HTMLInputElement') && element.type === 'time';
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
- prevValue
40
- } = (0, _shared.fireInputEventIfNeeded)({
41
- newValue,
42
- newSelectionStart,
43
- eventOverrides: {
44
- data: keyDef.key,
45
- inputType: 'insertText'
46
- },
47
- currentElement: () => element
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.isInstanceOfElement)(element, 'HTMLInputElement') && element.type === 'date';
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, _shared.fireInputEventIfNeeded)({
74
- newValue,
75
- newSelectionStart,
76
- eventOverrides: {
77
- data: keyDef.key,
78
- inputType: 'insertText'
79
- },
80
- currentElement: () => element
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.isInstanceOfElement)(element, 'HTMLInputElement') && element.type === 'number';
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.fireInputEventIfNeeded)({
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.isInstanceOfElement)(element, 'HTMLInputElement') || (0, _utils.isInstanceOfElement)(element, 'HTMLTextAreaElement') || (0, _utils.isContentEditable)(element));
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.fireInputEventIfNeeded)({
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.isInstanceOfElement)(element, 'HTMLTextAreaElement') || (0, _utils.isContentEditable)(element)),
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.fireInputEventIfNeeded)({
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.isInstanceOfElement)(element, 'HTMLInputElement') || (0, _utils.isInstanceOfElement)(element, 'HTMLTextAreaElement') || (0, _utils.isContentEditable)(element)),
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.setSelectionRangeIfNecessary)(element, 0, 0);
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.setSelectionRangeIfNecessary)(element, newPos, newPos);
28
+ (0, _utils.setSelectionRange)(element, newPos, newPos);
31
29
  }
32
30
  }
33
31
  }, {
34
- matches: keyDef => keyDef.key === 'Delete',
35
- handle: (keDef, element) => {
36
- (0, _shared.fireInputEventIfNeeded)({ ...(0, _calculateNewDeleteValue.calculateNewDeleteValue)(element),
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, _calculateBackspaceValue.calculateNewBackspaceValue)(element, state.carryValue);
64
- (0, _shared.fireInputEventIfNeeded)({
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.isInstanceOfElement)(element, 'HTMLAnchorElement') && Boolean(element.href)),
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.isInstanceOfElement)(element, 'HTMLInputElement'),
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' && ((0, _utils.isInstanceOfElement)(element, 'HTMLInputElement') || (0, _utils.isInstanceOfElement)(element, 'HTMLTextAreaElement')),
22
- handle: (keyDef, element) => {
23
- ;
24
- element.select();
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,2 @@
1
+ import { keyboardState } from '../types';
2
+ export declare function carryValue(element: Element, state: keyboardState, newValue: string): void;
@@ -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 fireInputEventIfNeeded({ currentElement, newValue, newSelectionStart, eventOverrides, }: {
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
+ }
@@ -1,3 +1,3 @@
1
+ export * from './carryValue';
1
2
  export * from './fireChangeForInputTimeIfValid';
2
- export * from './fireInputEventIfNeeded';
3
- export * from './setSelectionRange';
3
+ export * from './fireInputEvent';
@@ -4,41 +4,41 @@ Object.defineProperty(exports, "__esModule", {
4
4
  value: true
5
5
  });
6
6
 
7
- var _fireChangeForInputTimeIfValid = require("./fireChangeForInputTimeIfValid");
7
+ var _carryValue = require("./carryValue");
8
8
 
9
- Object.keys(_fireChangeForInputTimeIfValid).forEach(function (key) {
9
+ Object.keys(_carryValue).forEach(function (key) {
10
10
  if (key === "default" || key === "__esModule") return;
11
- if (key in exports && exports[key] === _fireChangeForInputTimeIfValid[key]) return;
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 _fireChangeForInputTimeIfValid[key];
15
+ return _carryValue[key];
16
16
  }
17
17
  });
18
18
  });
19
19
 
20
- var _fireInputEventIfNeeded = require("./fireInputEventIfNeeded");
20
+ var _fireChangeForInputTimeIfValid = require("./fireChangeForInputTimeIfValid");
21
21
 
22
- Object.keys(_fireInputEventIfNeeded).forEach(function (key) {
22
+ Object.keys(_fireChangeForInputTimeIfValid).forEach(function (key) {
23
23
  if (key === "default" || key === "__esModule") return;
24
- if (key in exports && exports[key] === _fireInputEventIfNeeded[key]) return;
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 _fireInputEventIfNeeded[key];
28
+ return _fireChangeForInputTimeIfValid[key];
29
29
  }
30
30
  });
31
31
  });
32
32
 
33
- var _setSelectionRange = require("./setSelectionRange");
33
+ var _fireInputEvent = require("./fireInputEvent");
34
34
 
35
- Object.keys(_setSelectionRange).forEach(function (key) {
35
+ Object.keys(_fireInputEvent).forEach(function (key) {
36
36
  if (key === "default" || key === "__esModule") return;
37
- if (key in exports && exports[key] === _setSelectionRange[key]) return;
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 _setSelectionRange[key];
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.setSelectionRangeIfNecessary)(element, initialSelectionStart != null ? initialSelectionStart : element.value.length, initialSelectionEnd != null ? initialSelectionEnd : element.value.length);
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 (!element.readOnly) {
41
- const {
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
  }
@@ -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.isInstanceOfElement)(select, 'HTMLSelectElement')) {
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.setSelectionRangeIfNecessary)(currentElement(), initialSelectionStart != null ? initialSelectionStart : value.length, initialSelectionEnd != null ? initialSelectionEnd : value.length);
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.isInstanceOfElement)(element, 'HTMLLabelElement') ? element.control : element;
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 _isInstanceOfElement = require("../misc/isInstanceOfElement");
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.tagName === 'BUTTON' || (0, _isInstanceOfElement.isInstanceOfElement)(element, 'HTMLInputElement') && CLICKABLE_INPUT_TYPES.includes(element.type);
13
+ return (0, _isElementType.isElementType)(element, 'button') || (0, _isElementType.isElementType)(element, 'input') && CLICKABLE_INPUT_TYPES.includes(element.type);
14
14
  }