@codingame/monaco-vscode-keybindings-service-override 5.2.0 → 6.0.0

package/vscode/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.js

@@ -1,12 +1,14 @@
-import { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE, ScanCodeUtils, NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE } from 'vscode/vscode/vs/base/common/keyCodes';
+import { CharCode } from 'vscode/vscode/vs/base/common/charCode';
+import { KeyCodeUtils, KeyCode, ScanCode, IMMUTABLE_CODE_TO_KEY_CODE, ScanCodeUtils, NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE } from 'vscode/vscode/vs/base/common/keyCodes';
 import { ScanCodeChord, KeyCodeChord } from 'vscode/vscode/vs/base/common/keybindings';
 import { UILabelProvider } from 'vscode/vscode/vs/base/common/keybindingLabels';
+import { OperatingSystem } from 'vscode/vscode/vs/base/common/platform';
 import { BaseResolvedKeybinding } from 'vscode/vscode/vs/platform/keybinding/common/baseResolvedKeybinding';
 import { toEmptyArrayIfContainsNull } from 'vscode/vscode/vs/platform/keybinding/common/resolvedKeybindingItem';
 
 class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
     constructor(mapper, chords) {
-        super(1 , chords);
+        super(OperatingSystem.Windows, chords);
         this._mapper = mapper;
     }
     _getLabel(chord) {
@@ -44,10 +46,10 @@ class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
         return this.__isWYSIWYG(chord.keyCode);
     }
     __isWYSIWYG(keyCode) {
-        if (keyCode === 15
-            || keyCode === 16
-            || keyCode === 17
-            || keyCode === 18 ) {
+        if (keyCode === KeyCode.LeftArrow
+            || keyCode === KeyCode.UpArrow
+            || keyCode === KeyCode.RightArrow
+            || keyCode === KeyCode.DownArrow) {
             return true;
         }
         const ariaLabel = this._mapper.getAriaLabelForKeyCode(keyCode);
@@ -75,16 +77,16 @@ class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
         return result;
     }
     _getSingleModifierChordDispatch(chord) {
-        if (chord.keyCode === 5  && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
+        if (chord.keyCode === KeyCode.Ctrl && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
             return 'ctrl';
         }
-        if (chord.keyCode === 4  && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
+        if (chord.keyCode === KeyCode.Shift && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
             return 'shift';
         }
-        if (chord.keyCode === 6  && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
+        if (chord.keyCode === KeyCode.Alt && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
             return 'alt';
         }
-        if (chord.keyCode === 57  && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
+        if (chord.keyCode === KeyCode.Meta && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
             return 'meta';
         }
         return null;
@@ -120,10 +122,10 @@ class WindowsKeyboardMapper {
         this._scanCodeToKeyCode = [];
         this._keyCodeToLabel = [];
         this._keyCodeExists = [];
-        this._keyCodeToLabel[0 ] = ( KeyCodeUtils.toString(0 ));
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+        this._keyCodeToLabel[KeyCode.Unknown] = ( KeyCodeUtils.toString(KeyCode.Unknown));
+        for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
             const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
-            if (immutableKeyCode !== -1 ) {
+            if (immutableKeyCode !== KeyCode.DependsOnKbLayout) {
                 this._scanCodeToKeyCode[scanCode] = immutableKeyCode;
                 this._keyCodeToLabel[immutableKeyCode] = ( KeyCodeUtils.toString(immutableKeyCode));
                 this._keyCodeExists[immutableKeyCode] = true;
@@ -135,17 +137,17 @@ class WindowsKeyboardMapper {
         for (const strCode in rawMappings) {
             if (rawMappings.hasOwnProperty(strCode)) {
                 const scanCode = ScanCodeUtils.toEnum(strCode);
-                if (scanCode === 0 ) {
+                if (scanCode === ScanCode.None) {
                     continue;
                 }
                 const rawMapping = rawMappings[strCode];
                 const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
-                if (immutableKeyCode !== -1 ) {
-                    const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || 0 ;
-                    if (keyCode === 0  || immutableKeyCode === keyCode) {
+                if (immutableKeyCode !== KeyCode.DependsOnKbLayout) {
+                    const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || KeyCode.Unknown;
+                    if (keyCode === KeyCode.Unknown || immutableKeyCode === keyCode) {
                         continue;
                     }
-                    if (scanCode !== 134 ) {
+                    if (scanCode !== ScanCode.NumpadComma) {
                         continue;
                     }
                 }
@@ -153,7 +155,7 @@ class WindowsKeyboardMapper {
                 const withShift = rawMapping.withShift;
                 const withAltGr = rawMapping.withAltGr;
                 const withShiftAltGr = rawMapping.withShiftAltGr;
-                const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || 0 ;
+                const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || KeyCode.Unknown;
                 const mapping = {
                     scanCode: scanCode,
                     keyCode: keyCode,
@@ -164,7 +166,7 @@ class WindowsKeyboardMapper {
                 };
                 this._codeInfo[scanCode] = mapping;
                 this._scanCodeToKeyCode[scanCode] = keyCode;
-                if (keyCode === 0 ) {
+                if (keyCode === KeyCode.Unknown) {
                     continue;
                 }
                 this._keyCodeExists[keyCode] = true;
@@ -176,13 +178,13 @@ class WindowsKeyboardMapper {
                 }
                 else {
                     const charCode = value.charCodeAt(0);
-                    if (charCode >= 97  && charCode <= 122 ) {
-                        const upperCaseValue = 65  + ((charCode - 97) );
+                    if (charCode >= CharCode.a && charCode <= CharCode.z) {
+                        const upperCaseValue = CharCode.A + (charCode - CharCode.a);
                         producesLetter[upperCaseValue] = true;
                         producesLetters = true;
-                        this._keyCodeToLabel[keyCode] = String.fromCharCode(65  + ((charCode - 97) ));
+                        this._keyCodeToLabel[keyCode] = String.fromCharCode(CharCode.A + (charCode - CharCode.a));
                     }
-                    else if (charCode >= 65  && charCode <= 90 ) {
+                    else if (charCode >= CharCode.A && charCode <= CharCode.Z) {
                         producesLetter[charCode] = true;
                         producesLetters = true;
                         this._keyCodeToLabel[keyCode] = value;
@@ -198,59 +200,59 @@ class WindowsKeyboardMapper {
                 this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
             }
         };
-        _registerLetterIfMissing(65 , 31 );
-        _registerLetterIfMissing(66 , 32 );
-        _registerLetterIfMissing(67 , 33 );
-        _registerLetterIfMissing(68 , 34 );
-        _registerLetterIfMissing(69 , 35 );
-        _registerLetterIfMissing(70 , 36 );
-        _registerLetterIfMissing(71 , 37 );
-        _registerLetterIfMissing(72 , 38 );
-        _registerLetterIfMissing(73 , 39 );
-        _registerLetterIfMissing(74 , 40 );
-        _registerLetterIfMissing(75 , 41 );
-        _registerLetterIfMissing(76 , 42 );
-        _registerLetterIfMissing(77 , 43 );
-        _registerLetterIfMissing(78 , 44 );
-        _registerLetterIfMissing(79 , 45 );
-        _registerLetterIfMissing(80 , 46 );
-        _registerLetterIfMissing(81 , 47 );
-        _registerLetterIfMissing(82 , 48 );
-        _registerLetterIfMissing(83 , 49 );
-        _registerLetterIfMissing(84 , 50 );
-        _registerLetterIfMissing(85 , 51 );
-        _registerLetterIfMissing(86 , 52 );
-        _registerLetterIfMissing(87 , 53 );
-        _registerLetterIfMissing(88 , 54 );
-        _registerLetterIfMissing(89 , 55 );
-        _registerLetterIfMissing(90 , 56 );
+        _registerLetterIfMissing(CharCode.A, KeyCode.KeyA);
+        _registerLetterIfMissing(CharCode.B, KeyCode.KeyB);
+        _registerLetterIfMissing(CharCode.C, KeyCode.KeyC);
+        _registerLetterIfMissing(CharCode.D, KeyCode.KeyD);
+        _registerLetterIfMissing(CharCode.E, KeyCode.KeyE);
+        _registerLetterIfMissing(CharCode.F, KeyCode.KeyF);
+        _registerLetterIfMissing(CharCode.G, KeyCode.KeyG);
+        _registerLetterIfMissing(CharCode.H, KeyCode.KeyH);
+        _registerLetterIfMissing(CharCode.I, KeyCode.KeyI);
+        _registerLetterIfMissing(CharCode.J, KeyCode.KeyJ);
+        _registerLetterIfMissing(CharCode.K, KeyCode.KeyK);
+        _registerLetterIfMissing(CharCode.L, KeyCode.KeyL);
+        _registerLetterIfMissing(CharCode.M, KeyCode.KeyM);
+        _registerLetterIfMissing(CharCode.N, KeyCode.KeyN);
+        _registerLetterIfMissing(CharCode.O, KeyCode.KeyO);
+        _registerLetterIfMissing(CharCode.P, KeyCode.KeyP);
+        _registerLetterIfMissing(CharCode.Q, KeyCode.KeyQ);
+        _registerLetterIfMissing(CharCode.R, KeyCode.KeyR);
+        _registerLetterIfMissing(CharCode.S, KeyCode.KeyS);
+        _registerLetterIfMissing(CharCode.T, KeyCode.KeyT);
+        _registerLetterIfMissing(CharCode.U, KeyCode.KeyU);
+        _registerLetterIfMissing(CharCode.V, KeyCode.KeyV);
+        _registerLetterIfMissing(CharCode.W, KeyCode.KeyW);
+        _registerLetterIfMissing(CharCode.X, KeyCode.KeyX);
+        _registerLetterIfMissing(CharCode.Y, KeyCode.KeyY);
+        _registerLetterIfMissing(CharCode.Z, KeyCode.KeyZ);
         if (!producesLetters) {
             const _registerLabel = (keyCode, charCode) => {
                 this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
             };
-            _registerLabel(85 , 59 );
-            _registerLabel(86 , 61 );
-            _registerLabel(87 , 44 );
-            _registerLabel(88 , 45 );
-            _registerLabel(89 , 46 );
-            _registerLabel(90 , 47 );
-            _registerLabel(91 , 96 );
-            _registerLabel(92 , 91 );
-            _registerLabel(93 , 92 );
-            _registerLabel(94 , 93 );
-            _registerLabel(95 , 39 );
+            _registerLabel(KeyCode.Semicolon, CharCode.Semicolon);
+            _registerLabel(KeyCode.Equal, CharCode.Equals);
+            _registerLabel(KeyCode.Comma, CharCode.Comma);
+            _registerLabel(KeyCode.Minus, CharCode.Dash);
+            _registerLabel(KeyCode.Period, CharCode.Period);
+            _registerLabel(KeyCode.Slash, CharCode.Slash);
+            _registerLabel(KeyCode.Backquote, CharCode.BackTick);
+            _registerLabel(KeyCode.BracketLeft, CharCode.OpenSquareBracket);
+            _registerLabel(KeyCode.Backslash, CharCode.Backslash);
+            _registerLabel(KeyCode.BracketRight, CharCode.CloseSquareBracket);
+            _registerLabel(KeyCode.Quote, CharCode.SingleQuote);
         }
     }
     dumpDebugInfo() {
         const result = [];
         const immutableSamples = [
-            88 ,
-            104
+            ScanCode.ArrowUp,
+            ScanCode.Numpad0
         ];
         let cnt = 0;
         result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
-            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
+        for (let scanCode = ScanCode.None; scanCode < ScanCode.MAX_VALUE; scanCode++) {
+            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== KeyCode.DependsOnKbLayout) {
                 if (immutableSamples.indexOf(scanCode) === -1) {
                     continue;
                 }
@@ -310,7 +312,7 @@ class WindowsKeyboardMapper {
         return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
     }
     _getLabelForKeyCode(keyCode) {
-        return this._keyCodeToLabel[keyCode] || ( KeyCodeUtils.toString(0 ));
+        return this._keyCodeToLabel[keyCode] || ( KeyCodeUtils.toString(KeyCode.Unknown));
     }
     resolveKeyboardEvent(keyboardEvent) {
         const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
@@ -334,8 +336,8 @@ class WindowsKeyboardMapper {
             }
             return chord;
         }
-        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || 0 ;
-        if (keyCode === 0  || !this._keyCodeExists[keyCode]) {
+        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || KeyCode.Unknown;
+        if (keyCode === KeyCode.Unknown || !this._keyCodeExists[keyCode]) {
             return null;
         }
         return ( new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode));