@codingame/monaco-vscode-keybindings-service-override 11.1.2 → 12.0.1

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

@@ -1,12 +1,15 @@
-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 +47,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 +78,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 +123,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 +138,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 +156,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 +167,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 +179,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 +201,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 +313,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 +337,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));

package/keybindings.js

@@ -1,108 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { WorkbenchKeybindingService } from './vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
-import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
-import { IKeyboardLayoutService } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout.service';
-import { BrowserKeyboardLayoutService } from './vscode/src/vs/workbench/services/keybinding/browser/keyboardLayoutService.js';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
-import { CommandService } from './vscode/src/vs/workbench/services/commands/common/commandService.js';
-import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { WorkbenchContextKeysHandler } from './vscode/src/vs/workbench/browser/contextkeys.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import getServiceOverride$1, { initFile } from '@codingame/monaco-vscode-files-service-override';
-import { onRenderWorkbench } from 'vscode/lifecycle';
-import 'vscode/vscode/vs/workbench/browser/workbench.contribution';
-import './vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js';
-import './vscode/src/vs/workbench/contrib/preferences/browser/keybindingsEditorContribution.js';
-import './vscode/src/vs/workbench/contrib/commands/common/commands.contribution.js';
-import { getService } from 'vscode/services';
-
-const defaultUserKeybindindsFile = ( URI.from({
-    scheme: Schemas.vscodeUserData,
-    path: '/User/keybindings.json'
-}));
-async function initUserKeybindings(configurationJson, options, file = defaultUserKeybindindsFile) {
-    await initFile(file, configurationJson, options);
-}
-async function updateUserKeybindings(keybindingsJson) {
-    const userDataProfilesService = await getService(IUserDataProfilesService);
-    const fileService = await getService(IFileService);
-    await fileService.writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
-}
-let DynamicWorkbenchKeybindingService = class DynamicWorkbenchKeybindingService extends WorkbenchKeybindingService {
-    constructor(shouldUseGlobalKeybindings, contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, uriIdentityService, logService, keyboardLayoutService) {
-        super(contextKeyService, commandService, telemetryService, notificationService, userDataProfileService, hostService, extensionService, fileService, uriIdentityService, logService, keyboardLayoutService);
-        this.shouldUseGlobalKeybindings = shouldUseGlobalKeybindings;
-        this.keybindingProviders = [];
-    }
-    registerKeybindingProvider(provider) {
-        this.keybindingProviders.push(provider);
-        this.updateResolver();
-        const store = new DisposableStore();
-        store.add(provider.onDidChangeKeybindings(() => {
-            this.updateResolver();
-        }));
-        store.add(toDisposable(() => {
-            const idx = this.keybindingProviders.indexOf(provider);
-            if (idx >= 0) {
-                this.keybindingProviders.splice(idx, 1);
-                this.updateResolver();
-            }
-        }));
-        return store;
-    }
-    _getResolver() {
-        return super._getResolver();
-    }
-    _dispatch(e, target) {
-        if (!this.shouldUseGlobalKeybindings()) {
-            return false;
-        }
-        return super._dispatch(e, target);
-    }
-    getUserKeybindingItems() {
-        return [
-            ...super.getUserKeybindingItems(),
-            ...this.keybindingProviders.flatMap((provider) => provider.provideKeybindings())
-        ];
-    }
-};
-DynamicWorkbenchKeybindingService = __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IUserDataProfileService)),
-    ( __param(6, IHostService)),
-    ( __param(7, IExtensionService)),
-    ( __param(8, IFileService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, ILogService)),
-    ( __param(11, IKeyboardLayoutService))
-], DynamicWorkbenchKeybindingService);
-onRenderWorkbench((accessor) => {
-    accessor.get(IInstantiationService).createInstance(WorkbenchContextKeysHandler);
-});
-function getServiceOverride({ shouldUseGlobalKeybindings = () => false } = {}) {
-    return {
-        ...getServiceOverride$1(),
-        [( IKeybindingService.toString())]: new SyncDescriptor(DynamicWorkbenchKeybindingService, [shouldUseGlobalKeybindings], false),
-        [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService, [], true),
-        [( ICommandService.toString())]: new SyncDescriptor(CommandService, [], true)
-    };
-}
-
-export { getServiceOverride as default, defaultUserKeybindindsFile, initUserKeybindings, updateUserKeybindings };