handsontable 0.0.0-next-a1e4b4f-20230628 → 0.0.0-next-e697250-20230707

package/shortcutContexts/grid.js

@@ -0,0 +1,252 @@
+"use strict";
+
+exports.__esModule = true;
+exports.shortcutsGridContext = shortcutsGridContext;
+var _mixed = require("../helpers/mixed");
+var _constants = require("./constants");
+var _commands = require("./commands");
+/**
+ * The context that defines shortcut list available for selected cell or cells.
+ *
+ * @param {Handsontable} hot The Handsontable instance.
+ */
+function shortcutsGridContext(hot) {
+  var context = hot.getShortcutManager().addContext('grid');
+  var commandsPool = (0, _commands.createKeyboardShortcutCommandsPool)(hot);
+  var config = {
+    runOnlyIf: function runOnlyIf() {
+      var _hot$getSettings = hot.getSettings(),
+        navigableHeaders = _hot$getSettings.navigableHeaders;
+      return (0, _mixed.isDefined)(hot.getSelected()) && (navigableHeaders || !navigableHeaders && hot.countRenderedRows() > 0 && hot.countRenderedCols() > 0);
+    },
+    group: _constants.GRID_GROUP
+  };
+  context.addShortcuts([{
+    keys: [['F2']],
+    callback: function callback(event) {
+      return commandsPool.editorFastOpen(event);
+    }
+  }, {
+    keys: [['Enter'], ['Enter', 'Shift']],
+    callback: function callback(event, keys) {
+      return commandsPool.editorOpen(event, keys);
+    }
+  }, {
+    keys: [['Backspace'], ['Delete']],
+    callback: function callback() {
+      return commandsPool.emptySelectedCells();
+    }
+  }], {
+    group: _constants.EDITOR_EDIT_GROUP,
+    runOnlyIf: function runOnlyIf() {
+      return (0, _mixed.isDefined)(hot.getSelected());
+    }
+  });
+  context.addShortcuts([{
+    keys: [['Control/Meta', 'A'], ['Control/Meta', 'Shift', 'Space']],
+    callback: function callback() {
+      return commandsPool.selectAll();
+    }
+  }, {
+    keys: [['Control/Meta', 'Enter']],
+    callback: function callback() {
+      return commandsPool.populateSelectedCellsData();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !hot.getSelectedRangeLast().highlight.isHeader() && hot.getSelectedRangeLast().getCellsCount() > 1;
+    }
+  }, {
+    keys: [['Control', 'Space']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToColumns();
+    }
+  }, {
+    keys: [['Shift', 'Space']],
+    stopPropagation: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToRows();
+    }
+  }, {
+    keys: [['ArrowUp']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionUp();
+    }
+  }, {
+    keys: [['ArrowUp', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostTop();
+    }
+  }, {
+    keys: [['ArrowUp', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionUp();
+    }
+  }, {
+    keys: [['ArrowUp', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostTop();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByColumnHeader());
+    }
+  }, {
+    keys: [['ArrowDown']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionDown();
+    }
+  }, {
+    keys: [['ArrowDown', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostBottom();
+    }
+  }, {
+    keys: [['ArrowDown', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionDown();
+    }
+  }, {
+    keys: [['ArrowDown', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostBottom();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByColumnHeader());
+    }
+  }, {
+    keys: [['ArrowLeft']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionLeft();
+    }
+  }, {
+    keys: [['ArrowLeft', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostLeft();
+    }
+  }, {
+    keys: [['ArrowLeft', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionLeft();
+    }
+  }, {
+    keys: [['ArrowLeft', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostLeft();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByRowHeader());
+    }
+  }, {
+    keys: [['ArrowRight']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionRight();
+    }
+  }, {
+    keys: [['ArrowRight', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostRight();
+    }
+  }, {
+    keys: [['ArrowRight', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionRight();
+    }
+  }, {
+    keys: [['ArrowRight', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostRight();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByRowHeader());
+    }
+  }, {
+    keys: [['Home']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostInlineStart();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['Home', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostInlineStart();
+    }
+  }, {
+    keys: [['Home', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostTopInlineStart();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['End']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostInlineEnd();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['End', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostInlineEnd();
+    }
+  }, {
+    keys: [['End', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostBottomInlineEnd();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['PageUp']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionUpByViewportHight();
+    }
+  }, {
+    keys: [['PageUp', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionUpByViewportHeight();
+    }
+  }, {
+    keys: [['PageDown']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionDownByViewportHeight();
+    }
+  }, {
+    keys: [['PageDown', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionDownByViewportHeight();
+    }
+  }, {
+    keys: [['Tab']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionInlineStart();
+    }
+  }, {
+    keys: [['Shift', 'Tab']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionInlineEnd();
+    }
+  }, {
+    keys: [['Control/Meta', 'Backspace']],
+    callback: function callback() {
+      return commandsPool.scrollToFocusedCell();
+    }
+  }], config);
+}

package/shortcutContexts/grid.mjs

@@ -0,0 +1,248 @@
+import { isDefined } from "../helpers/mixed.mjs";
+import { GRID_GROUP, EDITOR_EDIT_GROUP } from "./constants.mjs";
+import { createKeyboardShortcutCommandsPool } from "./commands/index.mjs";
+/**
+ * The context that defines shortcut list available for selected cell or cells.
+ *
+ * @param {Handsontable} hot The Handsontable instance.
+ */
+export function shortcutsGridContext(hot) {
+  var context = hot.getShortcutManager().addContext('grid');
+  var commandsPool = createKeyboardShortcutCommandsPool(hot);
+  var config = {
+    runOnlyIf: function runOnlyIf() {
+      var _hot$getSettings = hot.getSettings(),
+        navigableHeaders = _hot$getSettings.navigableHeaders;
+      return isDefined(hot.getSelected()) && (navigableHeaders || !navigableHeaders && hot.countRenderedRows() > 0 && hot.countRenderedCols() > 0);
+    },
+    group: GRID_GROUP
+  };
+  context.addShortcuts([{
+    keys: [['F2']],
+    callback: function callback(event) {
+      return commandsPool.editorFastOpen(event);
+    }
+  }, {
+    keys: [['Enter'], ['Enter', 'Shift']],
+    callback: function callback(event, keys) {
+      return commandsPool.editorOpen(event, keys);
+    }
+  }, {
+    keys: [['Backspace'], ['Delete']],
+    callback: function callback() {
+      return commandsPool.emptySelectedCells();
+    }
+  }], {
+    group: EDITOR_EDIT_GROUP,
+    runOnlyIf: function runOnlyIf() {
+      return isDefined(hot.getSelected());
+    }
+  });
+  context.addShortcuts([{
+    keys: [['Control/Meta', 'A'], ['Control/Meta', 'Shift', 'Space']],
+    callback: function callback() {
+      return commandsPool.selectAll();
+    }
+  }, {
+    keys: [['Control/Meta', 'Enter']],
+    callback: function callback() {
+      return commandsPool.populateSelectedCellsData();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !hot.getSelectedRangeLast().highlight.isHeader() && hot.getSelectedRangeLast().getCellsCount() > 1;
+    }
+  }, {
+    keys: [['Control', 'Space']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToColumns();
+    }
+  }, {
+    keys: [['Shift', 'Space']],
+    stopPropagation: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToRows();
+    }
+  }, {
+    keys: [['ArrowUp']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionUp();
+    }
+  }, {
+    keys: [['ArrowUp', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostTop();
+    }
+  }, {
+    keys: [['ArrowUp', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionUp();
+    }
+  }, {
+    keys: [['ArrowUp', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostTop();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByColumnHeader());
+    }
+  }, {
+    keys: [['ArrowDown']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionDown();
+    }
+  }, {
+    keys: [['ArrowDown', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostBottom();
+    }
+  }, {
+    keys: [['ArrowDown', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionDown();
+    }
+  }, {
+    keys: [['ArrowDown', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostBottom();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByColumnHeader());
+    }
+  }, {
+    keys: [['ArrowLeft']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionLeft();
+    }
+  }, {
+    keys: [['ArrowLeft', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostLeft();
+    }
+  }, {
+    keys: [['ArrowLeft', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionLeft();
+    }
+  }, {
+    keys: [['ArrowLeft', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostLeft();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByRowHeader());
+    }
+  }, {
+    keys: [['ArrowRight']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionRight();
+    }
+  }, {
+    keys: [['ArrowRight', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostRight();
+    }
+  }, {
+    keys: [['ArrowRight', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionRight();
+    }
+  }, {
+    keys: [['ArrowRight', 'Shift', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostRight();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return !(hot.selection.isSelectedByCorner() || hot.selection.isSelectedByRowHeader());
+    }
+  }, {
+    keys: [['Home']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostInlineStart();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['Home', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostInlineStart();
+    }
+  }, {
+    keys: [['Home', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostTopInlineStart();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['End']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostInlineEnd();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['End', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionToMostInlineEnd();
+    }
+  }, {
+    keys: [['End', 'Control/Meta']],
+    captureCtrl: true,
+    callback: function callback() {
+      return commandsPool.moveCellSelectionToMostBottomInlineEnd();
+    },
+    runOnlyIf: function runOnlyIf() {
+      return hot.view.isMainTableNotFullyCoveredByOverlays();
+    }
+  }, {
+    keys: [['PageUp']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionUpByViewportHight();
+    }
+  }, {
+    keys: [['PageUp', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionUpByViewportHeight();
+    }
+  }, {
+    keys: [['PageDown']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionDownByViewportHeight();
+    }
+  }, {
+    keys: [['PageDown', 'Shift']],
+    callback: function callback() {
+      return commandsPool.extendCellsSelectionDownByViewportHeight();
+    }
+  }, {
+    keys: [['Tab']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionInlineStart();
+    }
+  }, {
+    keys: [['Shift', 'Tab']],
+    callback: function callback() {
+      return commandsPool.moveCellSelectionInlineEnd();
+    }
+  }, {
+    keys: [['Control/Meta', 'Backspace']],
+    callback: function callback() {
+      return commandsPool.scrollToFocusedCell();
+    }
+  }], config);
+}

package/shortcutContexts/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+require("core-js/modules/es.object.keys.js");
+exports.__esModule = true;
+var _exportNames = {
+  registerAllShortcutContexts: true
+};
+exports.registerAllShortcutContexts = registerAllShortcutContexts;
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _editor = require("./editor");
+var _grid = require("./grid");
+var _constants = require("./constants");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  exports[key] = _constants[key];
+});
+/**
+ * Register all shortcut contexts.
+ *
+ * @param {Handsontable} hotInstance The Handsontable instance.
+ */
+function registerAllShortcutContexts(hotInstance) {
+  [_editor.shortcutsEditorContext, _grid.shortcutsGridContext].forEach(function (context) {
+    return context(hotInstance);
+  });
+}

package/shortcutContexts/index.mjs

@@ -0,0 +1,15 @@
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import { shortcutsEditorContext } from "./editor.mjs";
+import { shortcutsGridContext } from "./grid.mjs";
+export * from "./constants.mjs";
+/**
+ * Register all shortcut contexts.
+ *
+ * @param {Handsontable} hotInstance The Handsontable instance.
+ */
+export function registerAllShortcutContexts(hotInstance) {
+  [shortcutsEditorContext, shortcutsGridContext].forEach(function (context) {
+    return context(hotInstance);
+  });
+}

package/shortcuts/context.js

@@ -5,6 +5,7 @@ require("core-js/modules/es.symbol.js");
 require("core-js/modules/es.symbol.description.js");
 require("core-js/modules/es.symbol.iterator.js");
 require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.regexp.to-string.js");
 require("core-js/modules/es.function.name.js");
 require("core-js/modules/es.array.from.js");
 require("core-js/modules/es.regexp.exec.js");

package/shortcuts/context.mjs

@@ -3,6 +3,7 @@ import "core-js/modules/es.symbol.js";
 import "core-js/modules/es.symbol.description.js";
 import "core-js/modules/es.symbol.iterator.js";
 import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.regexp.to-string.js";
 import "core-js/modules/es.function.name.js";
 import "core-js/modules/es.array.from.js";
 import "core-js/modules/es.regexp.exec.js";

package/shortcuts/manager.js

@@ -3,6 +3,7 @@
 exports.__esModule = true;
 exports.createShortcutManager = void 0;
 var _uniqueMap = require("../utils/dataStructures/uniqueMap");
+var _event = require("../helpers/dom/event");
 var _context = require("./context");
 var _recorder = require("./recorder");
 /* eslint-disable jsdoc/require-description-complete-sentence */
@@ -126,6 +127,7 @@ var createShortcutManager = function createShortcutManager(_ref) {
           event.preventDefault();
         }
         if (stopPropagation) {
+          (0, _event.stopImmediatePropagation)(event);
           event.stopPropagation();
         }
         if (isExecutionCancelled) {

package/shortcuts/manager.mjs

@@ -1,4 +1,5 @@
 import { createUniqueMap } from "../utils/dataStructures/uniqueMap.mjs";
+import { stopImmediatePropagation } from "../helpers/dom/event.mjs";
 import { createContext } from "./context.mjs";
 import { useRecorder } from "./recorder.mjs";
 /* eslint-disable jsdoc/require-description-complete-sentence */
@@ -121,6 +122,7 @@ export var createShortcutManager = function createShortcutManager(_ref) {
           event.preventDefault();
         }
         if (stopPropagation) {
+          stopImmediatePropagation(event);
           event.stopPropagation();
         }
         if (isExecutionCancelled) {

package/shortcuts/recorder.js

@@ -88,7 +88,7 @@ function useRecorder(ownerWindow, handleEvent, beforeKeyDown, afterKeyDown, call
     if (event.keyCode === 229 || result === false || (0, _event.isImmediatePropagationStopped)(event)) {
       return;
     }
-    var pressedKey = (0, _utils.normalizeEventKey)(event.key);
+    var pressedKey = (0, _utils.normalizeEventKey)(event);
     var extraModifierKeys = [];
     if (isModifierKey(pressedKey)) {
       modifierKeysObserver.press(pressedKey);
@@ -114,7 +114,7 @@ function useRecorder(ownerWindow, handleEvent, beforeKeyDown, afterKeyDown, call
     if (handleEvent(event) === false) {
       return;
     }
-    var pressedKey = (0, _utils.normalizeEventKey)(event.key);
+    var pressedKey = (0, _utils.normalizeEventKey)(event);
     if (isModifierKey(pressedKey) === false) {
       return;
     }

package/shortcuts/recorder.mjs

@@ -84,7 +84,7 @@ export function useRecorder(ownerWindow, handleEvent, beforeKeyDown, afterKeyDow
     if (event.keyCode === 229 || result === false || isImmediatePropagationStopped(event)) {
       return;
     }
-    var pressedKey = normalizeEventKey(event.key);
+    var pressedKey = normalizeEventKey(event);
     var extraModifierKeys = [];
     if (isModifierKey(pressedKey)) {
       modifierKeysObserver.press(pressedKey);
@@ -110,7 +110,7 @@ export function useRecorder(ownerWindow, handleEvent, beforeKeyDown, afterKeyDow
     if (handleEvent(event) === false) {
       return;
     }
-    var pressedKey = normalizeEventKey(event.key);
+    var pressedKey = normalizeEventKey(event);
     if (isModifierKey(pressedKey) === false) {
       return;
     }

package/shortcuts/utils.js

@@ -10,6 +10,10 @@ require("core-js/modules/web.dom-collections.iterator.js");
 require("core-js/modules/es.array.join.js");
 require("core-js/modules/es.array.sort.js");
 require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.replace.js");
 // This file handles key-name discrepancies between browsers.
 // For the list of discrepancies, go to: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values.
 var mappings = new Map([[' ', 'space'],
@@ -46,13 +50,25 @@ var getKeysList = function getKeysList(normalizedKeys) {
 };
 
 /**
- * Normalize a `KeyboardEvent.key` property, to use it for keyboard shortcuts.
+ * The regex tests if the event.code matches to the pattern and it's used to extract letters and digits from
+ * the string.
+ */
+exports.getKeysList = getKeysList;
+var codeToKeyRegExp = new RegExp('^(?:Key|Digit)([A-Z0-9])$');
+
+/**
+ * Normalizes a keyboard event key value to a key before its modification. When the keyboard event
+ * is triggered with Alt, Control or Shift keys the `key` property contains modified key e.g. for Alt+L
+ * it will be `ł`. But that value is only valid for polish keyboard layout. To fix that limitations, for
+ * letters and digits the value is taken from the `code` property which holds original value before
+ * transformation.
  *
- * @param {string} key KeyboardEvent's key property.
+ * @param {Event} event The KeyboardEvent object.
  * @returns {string}
  */
-exports.getKeysList = getKeysList;
-var normalizeEventKey = function normalizeEventKey(key) {
-  return key.toLowerCase();
+var normalizeEventKey = function normalizeEventKey(_ref) {
+  var key = _ref.key,
+    code = _ref.code;
+  return (codeToKeyRegExp.test(code) ? code.replace(codeToKeyRegExp, '$1') : key).toLowerCase();
 };
 exports.normalizeEventKey = normalizeEventKey;