@codingame/monaco-vscode-keybindings-service-override 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/services/keybinding/browser/keyboardLayouts/zh-hans.darwin.js

@@ -0,0 +1,126 @@
+import { KeyboardLayoutContribution } from './_.contribution.js';
+
+KeyboardLayoutContribution.INSTANCE.registerKeyboardLayout({
+    layout: { id: 'com.apple.inputmethod.SCIM.ITABC', lang: 'zh-Hans', localizedName: '搜狗拼音' },
+    secondaryLayouts: [],
+    mapping: {
+        KeyA: ['a', 'A', 'å', 'Å', 0],
+        KeyB: ['b', 'B', '∫', 'ı', 0],
+        KeyC: ['c', 'C', 'ç', 'Ç', 0],
+        KeyD: ['d', 'D', '∂', 'Î', 0],
+        KeyE: ['e', 'E', '´', '´', 4],
+        KeyF: ['f', 'F', 'ƒ', 'Ï', 0],
+        KeyG: ['g', 'G', '©', '˝', 0],
+        KeyH: ['h', 'H', '˙', 'Ó', 0],
+        KeyI: ['i', 'I', 'ˆ', 'ˆ', 4],
+        KeyJ: ['j', 'J', '∆', 'Ô', 0],
+        KeyK: ['k', 'K', '˚', '', 0],
+        KeyL: ['l', 'L', '¬', 'Ò', 0],
+        KeyM: ['m', 'M', 'µ', 'Â', 0],
+        KeyN: ['n', 'N', '˜', '˜', 4],
+        KeyO: ['o', 'O', 'ø', 'Ø', 0],
+        KeyP: ['p', 'P', 'π', '∏', 0],
+        KeyQ: ['q', 'Q', 'œ', 'Œ', 0],
+        KeyR: ['r', 'R', '®', '‰', 0],
+        KeyS: ['s', 'S', 'ß', 'Í', 0],
+        KeyT: ['t', 'T', '†', 'ˇ', 0],
+        KeyU: ['u', 'U', '¨', '¨', 4],
+        KeyV: ['v', 'V', '√', '◊', 0],
+        KeyW: ['w', 'W', '∑', '„', 0],
+        KeyX: ['x', 'X', '≈', '˛', 0],
+        KeyY: ['y', 'Y', '¥', 'Á', 0],
+        KeyZ: ['z', 'Z', 'Ω', '¸', 0],
+        Digit1: ['1', '！', '¡', '⁄', 0],
+        Digit2: ['2', '@', '™', '€', 0],
+        Digit3: ['3', '#', '£', '‹', 0],
+        Digit4: ['4', '¥', '¢', '›', 0],
+        Digit5: ['5', '%', '∞', 'fi', 0],
+        Digit6: ['6', '', '§', 'fl', 0],
+        Digit7: ['7', '&', '¶', '‡', 0],
+        Digit8: ['8', '*', '•', '°', 0],
+        Digit9: ['9', '（', 'ª', '·', 0],
+        Digit0: ['0', '）', 'º', '‚', 0],
+        Enter: [],
+        Escape: [],
+        Backspace: [],
+        Tab: [],
+        Space: [' ', ' ', ' ', ' ', 0],
+        Minus: ['-', '', '–', '—', 0],
+        Equal: ['=', '+', '≠', '±', 0],
+        BracketLeft: ['【', '「', '“', '”', 0],
+        BracketRight: ['】', '」', '‘', '’', 0],
+        Backslash: ['、', '|', '«', '»', 0],
+        Semicolon: ['；', '：', '…', 'Ú', 0],
+        Quote: ['\'', '"', 'æ', 'Æ', 0],
+        Backquote: ['·', '～', '`', '`', 4],
+        Comma: ['，', '《', '≤', '¯', 0],
+        Period: ['。', '》', '≥', '˘', 0],
+        Slash: ['/', '？', '÷', '¿', 0],
+        CapsLock: [],
+        F1: [],
+        F2: [],
+        F3: [],
+        F4: [],
+        F5: [],
+        F6: [],
+        F7: [],
+        F8: [],
+        F9: [],
+        F10: [],
+        F11: [],
+        F12: [],
+        Insert: [],
+        Home: [],
+        PageUp: [],
+        Delete: [],
+        End: [],
+        PageDown: [],
+        ArrowRight: [],
+        ArrowLeft: [],
+        ArrowDown: [],
+        ArrowUp: [],
+        NumLock: [],
+        NumpadDivide: ['/', '/', '/', '/', 0],
+        NumpadMultiply: ['*', '*', '*', '*', 0],
+        NumpadSubtract: ['-', '-', '-', '-', 0],
+        NumpadAdd: ['+', '+', '+', '+', 0],
+        NumpadEnter: [],
+        Numpad1: ['1', '1', '1', '1', 0],
+        Numpad2: ['2', '2', '2', '2', 0],
+        Numpad3: ['3', '3', '3', '3', 0],
+        Numpad4: ['4', '4', '4', '4', 0],
+        Numpad5: ['5', '5', '5', '5', 0],
+        Numpad6: ['6', '6', '6', '6', 0],
+        Numpad7: ['7', '7', '7', '7', 0],
+        Numpad8: ['8', '8', '8', '8', 0],
+        Numpad9: ['9', '9', '9', '9', 0],
+        Numpad0: ['0', '0', '0', '0', 0],
+        NumpadDecimal: ['.', '.', '.', '.', 0],
+        IntlBackslash: ['§', '±', '§', '±', 0],
+        ContextMenu: [],
+        NumpadEqual: ['=', '=', '=', '=', 0],
+        F13: [],
+        F14: [],
+        F15: [],
+        F16: [],
+        F17: [],
+        F18: [],
+        F19: [],
+        F20: [],
+        AudioVolumeMute: [],
+        AudioVolumeUp: ['', '=', '', '=', 0],
+        AudioVolumeDown: [],
+        NumpadComma: [],
+        IntlRo: [],
+        KanaMode: [],
+        IntlYen: [],
+        ControlLeft: [],
+        ShiftLeft: [],
+        AltLeft: [],
+        MetaLeft: [],
+        ControlRight: [],
+        ShiftRight: [],
+        AltRight: [],
+        MetaRight: []
+    }
+});

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

@@ -0,0 +1,74 @@
+import { KeybindingParser } from 'vscode/vscode/vs/base/common/keybindingParser';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+
+class KeybindingIO {
+    static writeKeybindingItem(out, item) {
+        if (!item.resolvedKeybinding) {
+            return;
+        }
+        const quotedSerializedKeybinding = JSON.stringify(item.resolvedKeybinding.getUserSettingsLabel());
+        out.write(`{ "key": ${rightPaddedString(quotedSerializedKeybinding + ',', 25)} "command": `);
+        const quotedSerializedWhen = item.when ? JSON.stringify(item.when.serialize()) : '';
+        const quotedSerializeCommand = JSON.stringify(item.command);
+        if (quotedSerializedWhen.length > 0) {
+            out.write(`${quotedSerializeCommand},`);
+            out.writeLine();
+            out.write(`                                     "when": ${quotedSerializedWhen}`);
+        }
+        else {
+            out.write(`${quotedSerializeCommand}`);
+        }
+        if (item.commandArgs) {
+            out.write(',');
+            out.writeLine();
+            out.write(`                                     "args": ${JSON.stringify(item.commandArgs)}`);
+        }
+        out.write(' }');
+    }
+    static readUserKeybindingItem(input) {
+        const keybinding = 'key' in input && typeof input.key === 'string'
+            ? KeybindingParser.parseKeybinding(input.key)
+            : null;
+        const when = 'when' in input && typeof input.when === 'string'
+            ? ContextKeyExpr.deserialize(input.when)
+            : undefined;
+        const command = 'command' in input && typeof input.command === 'string'
+            ? input.command
+            : null;
+        const commandArgs = 'args' in input && typeof input.args !== 'undefined'
+            ? input.args
+            : undefined;
+        return {
+            keybinding,
+            command,
+            commandArgs,
+            when,
+            _sourceKey: 'key' in input && typeof input.key === 'string' ? input.key : undefined,
+        };
+    }
+}
+function rightPaddedString(str, minChars) {
+    if (str.length < minChars) {
+        return str + (( new Array(minChars - str.length)).join(' '));
+    }
+    return str;
+}
+class OutputBuilder {
+    constructor() {
+        this._lines = [];
+        this._currentLine = '';
+    }
+    write(str) {
+        this._currentLine += str;
+    }
+    writeLine(str = '') {
+        this._lines.push(this._currentLine + str);
+        this._currentLine = '';
+    }
+    toString() {
+        this.writeLine();
+        return this._lines.join('\n');
+    }
+}
+
+export { KeybindingIO, OutputBuilder };

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

@@ -0,0 +1,110 @@
+import { isWindows, isLinux } from 'vscode/vscode/vs/base/common/platform';
+import { getKeyboardLayoutId } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
+
+function deserializeMapping(serializedMapping) {
+    const mapping = serializedMapping;
+    const ret = {};
+    for (const key in mapping) {
+        const result = mapping[key];
+        if (result.length) {
+            const value = result[0];
+            const withShift = result[1];
+            const withAltGr = result[2];
+            const withShiftAltGr = result[3];
+            const mask = Number(result[4]);
+            const vkey = result.length === 6 ? result[5] : undefined;
+            ret[key] = {
+                'value': value,
+                'vkey': vkey,
+                'withShift': withShift,
+                'withAltGr': withAltGr,
+                'withShiftAltGr': withShiftAltGr,
+                'valueIsDeadKey': (mask & 1) > 0,
+                'withShiftIsDeadKey': (mask & 2) > 0,
+                'withAltGrIsDeadKey': (mask & 4) > 0,
+                'withShiftAltGrIsDeadKey': (mask & 8) > 0
+            };
+        }
+        else {
+            ret[key] = {
+                'value': '',
+                'valueIsDeadKey': false,
+                'withShift': '',
+                'withShiftIsDeadKey': false,
+                'withAltGr': '',
+                'withAltGrIsDeadKey': false,
+                'withShiftAltGr': '',
+                'withShiftAltGrIsDeadKey': false
+            };
+        }
+    }
+    return ret;
+}
+class KeymapInfo {
+    constructor(layout, secondaryLayouts, keyboardMapping, isUserKeyboardLayout) {
+        this.layout = layout;
+        this.secondaryLayouts = secondaryLayouts;
+        this.mapping = deserializeMapping(keyboardMapping);
+        this.isUserKeyboardLayout = !!isUserKeyboardLayout;
+        this.layout.isUserKeyboardLayout = !!isUserKeyboardLayout;
+    }
+    static createKeyboardLayoutFromDebugInfo(layout, value, isUserKeyboardLayout) {
+        const keyboardLayoutInfo = ( new KeymapInfo(layout, [], {}, true));
+        keyboardLayoutInfo.mapping = value;
+        return keyboardLayoutInfo;
+    }
+    update(other) {
+        this.layout = other.layout;
+        this.secondaryLayouts = other.secondaryLayouts;
+        this.mapping = other.mapping;
+        this.isUserKeyboardLayout = other.isUserKeyboardLayout;
+        this.layout.isUserKeyboardLayout = other.isUserKeyboardLayout;
+    }
+    getScore(other) {
+        let score = 0;
+        for (const key in other) {
+            if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+                continue;
+            }
+            if (isLinux && (key === 'Backspace' || key === 'Escape')) {
+                continue;
+            }
+            const currentMapping = this.mapping[key];
+            if (currentMapping === undefined) {
+                score -= 1;
+            }
+            const otherMapping = other[key];
+            if (currentMapping && otherMapping && currentMapping.value !== otherMapping.value) {
+                score -= 1;
+            }
+        }
+        return score;
+    }
+    equal(other) {
+        if (this.isUserKeyboardLayout !== other.isUserKeyboardLayout) {
+            return false;
+        }
+        if (getKeyboardLayoutId(this.layout) !== getKeyboardLayoutId(other.layout)) {
+            return false;
+        }
+        return this.fuzzyEqual(other.mapping);
+    }
+    fuzzyEqual(other) {
+        for (const key in other) {
+            if (isWindows && (key === 'Backslash' || key === 'KeyQ')) {
+                continue;
+            }
+            if (this.mapping[key] === undefined) {
+                return false;
+            }
+            const currentMapping = this.mapping[key];
+            const otherMapping = other[key];
+            if (currentMapping.value !== otherMapping.value) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+export { KeymapInfo };