@novnc/novnc 1.0.0 → 1.2.0

package/lib/input/util.js

@@ -0,0 +1,304 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKeycode = getKeycode;
+exports.getKey = getKey;
+exports.getKeysym = getKeysym;
+
+var _keysym = _interopRequireDefault(require("./keysym.js"));
+
+var _keysymdef = _interopRequireDefault(require("./keysymdef.js"));
+
+var _vkeys = _interopRequireDefault(require("./vkeys.js"));
+
+var _fixedkeys = _interopRequireDefault(require("./fixedkeys.js"));
+
+var _domkeytable = _interopRequireDefault(require("./domkeytable.js"));
+
+var browser = _interopRequireWildcard(require("../util/browser.js"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (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; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Get 'KeyboardEvent.code', handling legacy browsers
+function getKeycode(evt) {
+  // Are we getting proper key identifiers?
+  // (unfortunately Firefox and Chrome are crappy here and gives
+  // us an empty string on some platforms, rather than leaving it
+  // undefined)
+  if (evt.code) {
+    // Mozilla isn't fully in sync with the spec yet
+    switch (evt.code) {
+      case 'OSLeft':
+        return 'MetaLeft';
+
+      case 'OSRight':
+        return 'MetaRight';
+    }
+
+    return evt.code;
+  } // The de-facto standard is to use Windows Virtual-Key codes
+  // in the 'keyCode' field for non-printable characters. However
+  // Webkit sets it to the same as charCode in 'keypress' events.
+
+
+  if (evt.type !== 'keypress' && evt.keyCode in _vkeys.default) {
+    var code = _vkeys.default[evt.keyCode]; // macOS has messed up this code for some reason
+
+    if (browser.isMac() && code === 'ContextMenu') {
+      code = 'MetaRight';
+    } // The keyCode doesn't distinguish between left and right
+    // for the standard modifiers
+
+
+    if (evt.location === 2) {
+      switch (code) {
+        case 'ShiftLeft':
+          return 'ShiftRight';
+
+        case 'ControlLeft':
+          return 'ControlRight';
+
+        case 'AltLeft':
+          return 'AltRight';
+      }
+    } // Nor a bunch of the numpad keys
+
+
+    if (evt.location === 3) {
+      switch (code) {
+        case 'Delete':
+          return 'NumpadDecimal';
+
+        case 'Insert':
+          return 'Numpad0';
+
+        case 'End':
+          return 'Numpad1';
+
+        case 'ArrowDown':
+          return 'Numpad2';
+
+        case 'PageDown':
+          return 'Numpad3';
+
+        case 'ArrowLeft':
+          return 'Numpad4';
+
+        case 'ArrowRight':
+          return 'Numpad6';
+
+        case 'Home':
+          return 'Numpad7';
+
+        case 'ArrowUp':
+          return 'Numpad8';
+
+        case 'PageUp':
+          return 'Numpad9';
+
+        case 'Enter':
+          return 'NumpadEnter';
+      }
+    }
+
+    return code;
+  }
+
+  return 'Unidentified';
+} // Get 'KeyboardEvent.key', handling legacy browsers
+
+
+function getKey(evt) {
+  // Are we getting a proper key value?
+  if (evt.key !== undefined) {
+    // IE and Edge use some ancient version of the spec
+    // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8860571/
+    switch (evt.key) {
+      case 'Spacebar':
+        return ' ';
+
+      case 'Esc':
+        return 'Escape';
+
+      case 'Scroll':
+        return 'ScrollLock';
+
+      case 'Win':
+        return 'Meta';
+
+      case 'Apps':
+        return 'ContextMenu';
+
+      case 'Up':
+        return 'ArrowUp';
+
+      case 'Left':
+        return 'ArrowLeft';
+
+      case 'Right':
+        return 'ArrowRight';
+
+      case 'Down':
+        return 'ArrowDown';
+
+      case 'Del':
+        return 'Delete';
+
+      case 'Divide':
+        return '/';
+
+      case 'Multiply':
+        return '*';
+
+      case 'Subtract':
+        return '-';
+
+      case 'Add':
+        return '+';
+
+      case 'Decimal':
+        return evt.char;
+    } // Mozilla isn't fully in sync with the spec yet
+
+
+    switch (evt.key) {
+      case 'OS':
+        return 'Meta';
+
+      case 'LaunchMyComputer':
+        return 'LaunchApplication1';
+
+      case 'LaunchCalculator':
+        return 'LaunchApplication2';
+    } // iOS leaks some OS names
+
+
+    switch (evt.key) {
+      case 'UIKeyInputUpArrow':
+        return 'ArrowUp';
+
+      case 'UIKeyInputDownArrow':
+        return 'ArrowDown';
+
+      case 'UIKeyInputLeftArrow':
+        return 'ArrowLeft';
+
+      case 'UIKeyInputRightArrow':
+        return 'ArrowRight';
+
+      case 'UIKeyInputEscape':
+        return 'Escape';
+    } // Broken behaviour in Chrome
+
+
+    if (evt.key === '\x00' && evt.code === 'NumpadDecimal') {
+      return 'Delete';
+    } // IE and Edge need special handling, but for everyone else we
+    // can trust the value provided
+
+
+    if (!browser.isIE() && !browser.isEdge()) {
+      return evt.key;
+    } // IE and Edge have broken handling of AltGraph so we can only
+    // trust them for non-printable characters (and unfortunately
+    // they also specify 'Unidentified' for some problem keys)
+
+
+    if (evt.key.length !== 1 && evt.key !== 'Unidentified') {
+      return evt.key;
+    }
+  } // Try to deduce it based on the physical key
+
+
+  var code = getKeycode(evt);
+
+  if (code in _fixedkeys.default) {
+    return _fixedkeys.default[code];
+  } // If that failed, then see if we have a printable character
+
+
+  if (evt.charCode) {
+    return String.fromCharCode(evt.charCode);
+  } // At this point we have nothing left to go on
+
+
+  return 'Unidentified';
+} // Get the most reliable keysym value we can get from a key event
+
+
+function getKeysym(evt) {
+  var key = getKey(evt);
+
+  if (key === 'Unidentified') {
+    return null;
+  } // First look up special keys
+
+
+  if (key in _domkeytable.default) {
+    var location = evt.location; // Safari screws up location for the right cmd key
+
+    if (key === 'Meta' && location === 0) {
+      location = 2;
+    } // And for Clear
+
+
+    if (key === 'Clear' && location === 3) {
+      var code = getKeycode(evt);
+
+      if (code === 'NumLock') {
+        location = 0;
+      }
+    }
+
+    if (location === undefined || location > 3) {
+      location = 0;
+    } // The original Meta key now gets confused with the Windows key
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1020141
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1232918
+
+
+    if (key === 'Meta') {
+      var _code = getKeycode(evt);
+
+      if (_code === 'AltLeft') {
+        return _keysym.default.XK_Meta_L;
+      } else if (_code === 'AltRight') {
+        return _keysym.default.XK_Meta_R;
+      }
+    } // macOS has Clear instead of NumLock, but the remote system is
+    // probably not macOS, so lying here is probably best...
+
+
+    if (key === 'Clear') {
+      var _code2 = getKeycode(evt);
+
+      if (_code2 === 'NumLock') {
+        return _keysym.default.XK_Num_Lock;
+      }
+    }
+
+    return _domkeytable.default[key][location];
+  } // Now we need to look at the Unicode symbol instead
+  // Special key? (FIXME: Should have been caught earlier)
+
+
+  if (key.length !== 1) {
+    return null;
+  }
+
+  var codepoint = key.charCodeAt();
+
+  if (codepoint) {
+    return _keysymdef.default.lookup(codepoint);
+  }
+
+  return null;
+}

package/lib/input/vkeys.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2018 The noVNC Authors
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*
+ * Mapping between Microsoft® Windows® Virtual-Key codes and
+ * HTML key codes.
+ */
+var _default = {
+  0x08: 'Backspace',
+  0x09: 'Tab',
+  0x0a: 'NumpadClear',
+  0x0c: 'Numpad5',
+  // IE11 sends evt.keyCode: 12 when numlock is off
+  0x0d: 'Enter',
+  0x10: 'ShiftLeft',
+  0x11: 'ControlLeft',
+  0x12: 'AltLeft',
+  0x13: 'Pause',
+  0x14: 'CapsLock',
+  0x15: 'Lang1',
+  0x19: 'Lang2',
+  0x1b: 'Escape',
+  0x1c: 'Convert',
+  0x1d: 'NonConvert',
+  0x20: 'Space',
+  0x21: 'PageUp',
+  0x22: 'PageDown',
+  0x23: 'End',
+  0x24: 'Home',
+  0x25: 'ArrowLeft',
+  0x26: 'ArrowUp',
+  0x27: 'ArrowRight',
+  0x28: 'ArrowDown',
+  0x29: 'Select',
+  0x2c: 'PrintScreen',
+  0x2d: 'Insert',
+  0x2e: 'Delete',
+  0x2f: 'Help',
+  0x30: 'Digit0',
+  0x31: 'Digit1',
+  0x32: 'Digit2',
+  0x33: 'Digit3',
+  0x34: 'Digit4',
+  0x35: 'Digit5',
+  0x36: 'Digit6',
+  0x37: 'Digit7',
+  0x38: 'Digit8',
+  0x39: 'Digit9',
+  0x5b: 'MetaLeft',
+  0x5c: 'MetaRight',
+  0x5d: 'ContextMenu',
+  0x5f: 'Sleep',
+  0x60: 'Numpad0',
+  0x61: 'Numpad1',
+  0x62: 'Numpad2',
+  0x63: 'Numpad3',
+  0x64: 'Numpad4',
+  0x65: 'Numpad5',
+  0x66: 'Numpad6',
+  0x67: 'Numpad7',
+  0x68: 'Numpad8',
+  0x69: 'Numpad9',
+  0x6a: 'NumpadMultiply',
+  0x6b: 'NumpadAdd',
+  0x6c: 'NumpadDecimal',
+  0x6d: 'NumpadSubtract',
+  0x6e: 'NumpadDecimal',
+  // Duplicate, because buggy on Windows
+  0x6f: 'NumpadDivide',
+  0x70: 'F1',
+  0x71: 'F2',
+  0x72: 'F3',
+  0x73: 'F4',
+  0x74: 'F5',
+  0x75: 'F6',
+  0x76: 'F7',
+  0x77: 'F8',
+  0x78: 'F9',
+  0x79: 'F10',
+  0x7a: 'F11',
+  0x7b: 'F12',
+  0x7c: 'F13',
+  0x7d: 'F14',
+  0x7e: 'F15',
+  0x7f: 'F16',
+  0x80: 'F17',
+  0x81: 'F18',
+  0x82: 'F19',
+  0x83: 'F20',
+  0x84: 'F21',
+  0x85: 'F22',
+  0x86: 'F23',
+  0x87: 'F24',
+  0x90: 'NumLock',
+  0x91: 'ScrollLock',
+  0xa6: 'BrowserBack',
+  0xa7: 'BrowserForward',
+  0xa8: 'BrowserRefresh',
+  0xa9: 'BrowserStop',
+  0xaa: 'BrowserSearch',
+  0xab: 'BrowserFavorites',
+  0xac: 'BrowserHome',
+  0xad: 'AudioVolumeMute',
+  0xae: 'AudioVolumeDown',
+  0xaf: 'AudioVolumeUp',
+  0xb0: 'MediaTrackNext',
+  0xb1: 'MediaTrackPrevious',
+  0xb2: 'MediaStop',
+  0xb3: 'MediaPlayPause',
+  0xb4: 'LaunchMail',
+  0xb5: 'MediaSelect',
+  0xb6: 'LaunchApp1',
+  0xb7: 'LaunchApp2',
+  0xe1: 'AltRight' // Only when it is AltGraph
+
+};
+exports.default = _default;