Mail

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/arrow.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file should contain behavior for arrow keys as described here:
+ * https://w3c.github.io/uievents-code/#key-arrowpad-section
+ */
+import { behaviorPlugin } from '../types';
+export declare const keydownBehavior: behaviorPlugin[];

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/arrow.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keydownBehavior = void 0;
+
+var _utils = require("../../utils");
+
+/**
+ * This file should contain behavior for arrow keys as described here:
+ * https://w3c.github.io/uievents-code/#key-arrowpad-section
+ */
+const keydownBehavior = [{
+  // TODO: implement for contentEditable
+  matches: (keyDef, element) => (keyDef.key === 'ArrowLeft' || keyDef.key === 'ArrowRight') && (0, _utils.isElementType)(element, ['input', 'textarea']),
+  handle: (keyDef, element) => {
+    var _ref;
+
+    const {
+      selectionStart,
+      selectionEnd
+    } = (0, _utils.getSelectionRange)(element);
+    const direction = keyDef.key === 'ArrowLeft' ? -1 : 1;
+    const newPos = (_ref = selectionStart === selectionEnd ? (selectionStart != null ? selectionStart :
+    /* istanbul ignore next */
+    0) + direction : direction < 0 ? selectionStart : selectionEnd) != null ? _ref :
+    /* istanbul ignore next */
+    0;
+    (0, _utils.setSelectionRange)(element, newPos, newPos);
+  }
+}];
+exports.keydownBehavior = keydownBehavior;

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/character.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This file should cover the behavior for keys that produce character input
+ */
+import { behaviorPlugin } from '../types';
+export declare const keypressBehavior: behaviorPlugin[];

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/character.js

@@ -0,0 +1,195 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keypressBehavior = void 0;
+
+var _dom = require("@testing-library/dom");
+
+var _shared = require("../shared");
+
+var _utils = require("../../utils");
+
+/**
+ * This file should cover the behavior for keys that produce character input
+ */
+const keypressBehavior = [{
+  matches: (keyDef, element) => {
+    var _keyDef$key;
+
+    return ((_keyDef$key = keyDef.key) == null ? void 0 : _keyDef$key.length) === 1 && (0, _utils.isElementType)(element, 'input', {
+      type: 'time',
+      readOnly: false
+    });
+  },
+  handle: (keyDef, element, options, state) => {
+    var _state$carryValue;
+
+    let newEntry = keyDef.key;
+    const textToBeTyped = ((_state$carryValue = state.carryValue) != null ? _state$carryValue : '') + newEntry;
+    const timeNewEntry = (0, _utils.buildTimeValue)(textToBeTyped);
+
+    if ((0, _utils.isValidInputTimeValue)(element, timeNewEntry)) {
+      newEntry = timeNewEntry;
+    }
+
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)(newEntry, element);
+    const prevValue = (0, _utils.getValue)(element); // this check was provided by fireInputEventIfNeeded
+    // TODO: verify if it is even needed by this handler
+
+    if (prevValue !== newValue) {
+      (0, _shared.fireInputEvent)(element, {
+        newValue,
+        newSelectionStart,
+        eventOverrides: {
+          data: keyDef.key,
+          inputType: 'insertText'
+        }
+      });
+    }
+
+    (0, _shared.fireChangeForInputTimeIfValid)(element, prevValue, timeNewEntry);
+    state.carryValue = textToBeTyped;
+  }
+}, {
+  matches: (keyDef, element) => {
+    var _keyDef$key2;
+
+    return ((_keyDef$key2 = keyDef.key) == null ? void 0 : _keyDef$key2.length) === 1 && (0, _utils.isElementType)(element, 'input', {
+      type: 'date',
+      readOnly: false
+    });
+  },
+  handle: (keyDef, element, options, state) => {
+    var _state$carryValue2;
+
+    let newEntry = keyDef.key;
+    const textToBeTyped = ((_state$carryValue2 = state.carryValue) != null ? _state$carryValue2 : '') + newEntry;
+    const isValidToBeTyped = (0, _utils.isValidDateValue)(element, textToBeTyped);
+
+    if (isValidToBeTyped) {
+      newEntry = textToBeTyped;
+    }
+
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)(newEntry, element);
+    const prevValue = (0, _utils.getValue)(element); // this check was provided by fireInputEventIfNeeded
+    // TODO: verify if it is even needed by this handler
+
+    if (prevValue !== newValue) {
+      (0, _shared.fireInputEvent)(element, {
+        newValue,
+        newSelectionStart,
+        eventOverrides: {
+          data: keyDef.key,
+          inputType: 'insertText'
+        }
+      });
+    }
+
+    if (isValidToBeTyped) {
+      _dom.fireEvent.change(element, {
+        target: {
+          value: textToBeTyped
+        }
+      });
+    }
+
+    state.carryValue = textToBeTyped;
+  }
+}, {
+  matches: (keyDef, element) => {
+    var _keyDef$key3;
+
+    return ((_keyDef$key3 = keyDef.key) == null ? void 0 : _keyDef$key3.length) === 1 && (0, _utils.isElementType)(element, 'input', {
+      type: 'number',
+      readOnly: false
+    });
+  },
+  handle: (keyDef, element, options, state) => {
+    var _ref, _state$carryValue3, _newValue$match, _newValue$match2;
+
+    if (!/[\d.\-e]/.test(keyDef.key)) {
+      return;
+    }
+
+    const oldValue = (_ref = (_state$carryValue3 = state.carryValue) != null ? _state$carryValue3 : (0, _utils.getValue)(element)) != null ? _ref :
+    /* istanbul ignore next */
+    '';
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)(keyDef.key, element, oldValue); // the browser allows some invalid input but not others
+    // it allows up to two '-' at any place before any 'e' or one directly following 'e'
+    // it allows one '.' at any place before e
+
+    const valueParts = newValue.split('e', 2);
+
+    if (Number((_newValue$match = newValue.match(/-/g)) == null ? void 0 : _newValue$match.length) > 2 || Number((_newValue$match2 = newValue.match(/\./g)) == null ? void 0 : _newValue$match2.length) > 1 || valueParts[1] && !/^-?\d*$/.test(valueParts[1])) {
+      return;
+    }
+
+    (0, _shared.fireInputEvent)(element, {
+      newValue,
+      newSelectionStart,
+      eventOverrides: {
+        data: keyDef.key,
+        inputType: 'insertText'
+      }
+    });
+    const appliedValue = (0, _utils.getValue)(element);
+
+    if (appliedValue === newValue) {
+      state.carryValue = undefined;
+    } else {
+      state.carryValue = newValue;
+    }
+  }
+}, {
+  matches: (keyDef, element) => {
+    var _keyDef$key4;
+
+    return ((_keyDef$key4 = keyDef.key) == null ? void 0 : _keyDef$key4.length) === 1 && ((0, _utils.isElementType)(element, ['input', 'textarea'], {
+      readOnly: false
+    }) && !(0, _utils.isClickableInput)(element) || (0, _utils.isContentEditable)(element)) && (0, _utils.getSpaceUntilMaxLength)(element) !== 0;
+  },
+  handle: (keyDef, element) => {
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)(keyDef.key, element);
+    (0, _shared.fireInputEvent)(element, {
+      newValue,
+      newSelectionStart,
+      eventOverrides: {
+        data: keyDef.key,
+        inputType: 'insertText'
+      }
+    });
+  }
+}, {
+  matches: (keyDef, element) => keyDef.key === 'Enter' && ((0, _utils.isElementType)(element, 'textarea', {
+    readOnly: false
+  }) || (0, _utils.isContentEditable)(element)) && (0, _utils.getSpaceUntilMaxLength)(element) !== 0,
+  handle: (keyDef, element, options, state) => {
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)('\n', element);
+    const inputType = (0, _utils.isContentEditable)(element) && !state.modifiers.shift ? 'insertParagraph' : 'insertLineBreak';
+    (0, _shared.fireInputEvent)(element, {
+      newValue,
+      newSelectionStart,
+      eventOverrides: {
+        inputType
+      }
+    });
+  }
+}];
+exports.keypressBehavior = keypressBehavior;

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/control.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file should contain behavior for arrow keys as described here:
+ * https://w3c.github.io/uievents-code/#key-controlpad-section
+ */
+import { behaviorPlugin } from '../types';
+export declare const keydownBehavior: behaviorPlugin[];

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/control.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keydownBehavior = void 0;
+
+var _utils = require("../../utils");
+
+var _shared = require("../shared");
+
+/**
+ * This file should contain behavior for arrow keys as described here:
+ * https://w3c.github.io/uievents-code/#key-controlpad-section
+ */
+const keydownBehavior = [{
+  matches: (keyDef, element) => (keyDef.key === 'Home' || keyDef.key === 'End') && ((0, _utils.isElementType)(element, ['input', 'textarea']) || (0, _utils.isContentEditable)(element)),
+  handle: (keyDef, element) => {
+    // This could probably been improved by collapsing a selection range
+    if (keyDef.key === 'Home') {
+      (0, _utils.setSelectionRange)(element, 0, 0);
+    } else {
+      var _getValue$length, _getValue;
+
+      const newPos = (_getValue$length = (_getValue = (0, _utils.getValue)(element)) == null ? void 0 : _getValue.length) != null ? _getValue$length :
+      /* istanbul ignore next */
+      0;
+      (0, _utils.setSelectionRange)(element, newPos, newPos);
+    }
+  }
+}, {
+  matches: (keyDef, element) => (keyDef.key === 'PageUp' || keyDef.key === 'PageDown') && (0, _utils.isElementType)(element, ['input']),
+  handle: (keyDef, element) => {
+    // This could probably been improved by collapsing a selection range
+    if (keyDef.key === 'PageUp') {
+      (0, _utils.setSelectionRange)(element, 0, 0);
+    } else {
+      var _getValue$length2, _getValue2;
+
+      const newPos = (_getValue$length2 = (_getValue2 = (0, _utils.getValue)(element)) == null ? void 0 : _getValue2.length) != null ? _getValue$length2 :
+      /* istanbul ignore next */
+      0;
+      (0, _utils.setSelectionRange)(element, newPos, newPos);
+    }
+  }
+}, {
+  matches: (keyDef, element) => keyDef.key === 'Delete' && (0, _utils.isEditable)(element) && !(0, _utils.isCursorAtEnd)(element),
+  handle: (keDef, element, options, state) => {
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)('', element, state.carryValue, undefined, 'forward');
+    (0, _shared.fireInputEvent)(element, {
+      newValue,
+      newSelectionStart,
+      eventOverrides: {
+        inputType: 'deleteContentForward'
+      }
+    });
+    (0, _shared.carryValue)(element, state, newValue);
+  }
+}];
+exports.keydownBehavior = keydownBehavior;

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/functional.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This file should contain behavior for functional keys as described here:
+ * https://w3c.github.io/uievents-code/#key-alphanumeric-functional
+ */
+import { behaviorPlugin } from '../types';
+export declare const preKeydownBehavior: behaviorPlugin[];
+export declare const keydownBehavior: behaviorPlugin[];
+export declare const keypressBehavior: behaviorPlugin[];
+export declare const preKeyupBehavior: behaviorPlugin[];
+export declare const keyupBehavior: behaviorPlugin[];
+export declare const postKeyupBehavior: behaviorPlugin[];

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/functional.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.preKeyupBehavior = exports.preKeydownBehavior = exports.postKeyupBehavior = exports.keyupBehavior = exports.keypressBehavior = exports.keydownBehavior = void 0;
+
+var _dom = require("@testing-library/dom");
+
+var _utils = require("../../utils");
+
+var _getEventProps = require("../getEventProps");
+
+var _shared = require("../shared");
+
+/**
+ * This file should contain behavior for functional keys as described here:
+ * https://w3c.github.io/uievents-code/#key-alphanumeric-functional
+ */
+const modifierKeys = {
+  Alt: 'alt',
+  Control: 'ctrl',
+  Shift: 'shift',
+  Meta: 'meta'
+};
+const preKeydownBehavior = [// modifierKeys switch on the modifier BEFORE the keydown event
+...Object.entries(modifierKeys).map(([key, modKey]) => ({
+  matches: keyDef => keyDef.key === key,
+  handle: (keyDef, element, options, state) => {
+    state.modifiers[modKey] = true;
+  }
+})), // AltGraph produces an extra keydown for Control
+// The modifier does not change
+{
+  matches: keyDef => keyDef.key === 'AltGraph',
+  handle: (keyDef, element, options, state) => {
+    var _options$keyboardMap$;
+
+    const ctrlKeyDef = (_options$keyboardMap$ = options.keyboardMap.find(k => k.key === 'Control')) != null ? _options$keyboardMap$ :
+    /* istanbul ignore next */
+    {
+      key: 'Control',
+      code: 'Control'
+    };
+
+    _dom.fireEvent.keyDown(element, (0, _getEventProps.getKeyEventProps)(ctrlKeyDef, state));
+  }
+}];
+exports.preKeydownBehavior = preKeydownBehavior;
+const keydownBehavior = [{
+  matches: keyDef => keyDef.key === 'CapsLock',
+  handle: (keyDef, element, options, state) => {
+    state.modifiers.caps = !state.modifiers.caps;
+  }
+}, {
+  matches: (keyDef, element) => keyDef.key === 'Backspace' && (0, _utils.isEditable)(element) && !(0, _utils.isCursorAtStart)(element),
+  handle: (keyDef, element, options, state) => {
+    const {
+      newValue,
+      newSelectionStart
+    } = (0, _utils.calculateNewValue)('', element, state.carryValue, undefined, 'backward');
+    (0, _shared.fireInputEvent)(element, {
+      newValue,
+      newSelectionStart,
+      eventOverrides: {
+        inputType: 'deleteContentBackward'
+      }
+    });
+    (0, _shared.carryValue)(element, state, newValue);
+  }
+}];
+exports.keydownBehavior = keydownBehavior;
+const keypressBehavior = [{
+  matches: (keyDef, element) => keyDef.key === 'Enter' && (0, _utils.isElementType)(element, 'input') && ['checkbox', 'radio'].includes(element.type),
+  handle: (keyDef, element) => {
+    const form = element.form;
+
+    if ((0, _utils.hasFormSubmit)(form)) {
+      _dom.fireEvent.submit(form);
+    }
+  }
+}, {
+  matches: (keyDef, element) => keyDef.key === 'Enter' && ((0, _utils.isClickableInput)(element) || // Links with href defined should handle Enter the same as a click
+  (0, _utils.isElementType)(element, 'a') && Boolean(element.href)),
+  handle: (keyDef, element, options, state) => {
+    _dom.fireEvent.click(element, (0, _getEventProps.getMouseEventProps)(state));
+  }
+}, {
+  matches: (keyDef, element) => keyDef.key === 'Enter' && (0, _utils.isElementType)(element, 'input'),
+  handle: (keyDef, element) => {
+    const form = element.form;
+
+    if (form && (form.querySelectorAll('input').length === 1 || (0, _utils.hasFormSubmit)(form))) {
+      _dom.fireEvent.submit(form);
+    }
+  }
+}];
+exports.keypressBehavior = keypressBehavior;
+const preKeyupBehavior = [// modifierKeys switch off the modifier BEFORE the keyup event
+...Object.entries(modifierKeys).map(([key, modKey]) => ({
+  matches: keyDef => keyDef.key === key,
+  handle: (keyDef, element, options, state) => {
+    state.modifiers[modKey] = false;
+  }
+}))];
+exports.preKeyupBehavior = preKeyupBehavior;
+const keyupBehavior = [{
+  matches: (keyDef, element) => keyDef.key === ' ' && (0, _utils.isClickableInput)(element),
+  handle: (keyDef, element, options, state) => {
+    _dom.fireEvent.click(element, (0, _getEventProps.getMouseEventProps)(state));
+  }
+}];
+exports.keyupBehavior = keyupBehavior;
+const postKeyupBehavior = [// AltGraph produces an extra keyup for Control
+// The modifier does not change
+{
+  matches: keyDef => keyDef.key === 'AltGraph',
+  handle: (keyDef, element, options, state) => {
+    var _options$keyboardMap$2;
+
+    const ctrlKeyDef = (_options$keyboardMap$2 = options.keyboardMap.find(k => k.key === 'Control')) != null ? _options$keyboardMap$2 :
+    /* istanbul ignore next */
+    {
+      key: 'Control',
+      code: 'Control'
+    };
+
+    _dom.fireEvent.keyUp(element, (0, _getEventProps.getKeyEventProps)(ctrlKeyDef, state));
+  }
+}];
+exports.postKeyupBehavior = postKeyupBehavior;

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/index.d.ts

@@ -0,0 +1,8 @@
+import { behaviorPlugin } from '../types';
+export declare const replaceBehavior: behaviorPlugin[];
+export declare const preKeydownBehavior: behaviorPlugin[];
+export declare const keydownBehavior: behaviorPlugin[];
+export declare const keypressBehavior: behaviorPlugin[];
+export declare const preKeyupBehavior: behaviorPlugin[];
+export declare const keyupBehavior: behaviorPlugin[];
+export declare const postKeyupBehavior: behaviorPlugin[];

frontend/node_modules/@testing-library/user-event/dist/keyboard/plugins/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceBehavior = exports.preKeyupBehavior = exports.preKeydownBehavior = exports.postKeyupBehavior = exports.keyupBehavior = exports.keypressBehavior = exports.keydownBehavior = void 0;
+
+var _utils = require("../../utils");
+
+var arrowKeys = _interopRequireWildcard(require("./arrow"));
+
+var controlKeys = _interopRequireWildcard(require("./control"));
+
+var characterKeys = _interopRequireWildcard(require("./character"));
+
+var functionalKeys = _interopRequireWildcard(require("./functional"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const replaceBehavior = [{
+  matches: (keyDef, element) => keyDef.key === 'selectall' && (0, _utils.isElementType)(element, ['input', 'textarea']),
+  handle: (keyDef, element, options, state) => {
+    var _state$carryValue;
+
+    (0, _utils.setSelectionRange)(element, 0, ((_state$carryValue = state.carryValue) != null ? _state$carryValue : element.value).length);
+  }
+}];
+exports.replaceBehavior = replaceBehavior;
+const preKeydownBehavior = [...functionalKeys.preKeydownBehavior];
+exports.preKeydownBehavior = preKeydownBehavior;
+const keydownBehavior = [...arrowKeys.keydownBehavior, ...controlKeys.keydownBehavior, ...functionalKeys.keydownBehavior];
+exports.keydownBehavior = keydownBehavior;
+const keypressBehavior = [...functionalKeys.keypressBehavior, ...characterKeys.keypressBehavior];
+exports.keypressBehavior = keypressBehavior;
+const preKeyupBehavior = [...functionalKeys.preKeyupBehavior];
+exports.preKeyupBehavior = preKeyupBehavior;
+const keyupBehavior = [...functionalKeys.keyupBehavior];
+exports.keyupBehavior = keyupBehavior;
+const postKeyupBehavior = [...functionalKeys.postKeyupBehavior];
+exports.postKeyupBehavior = postKeyupBehavior;