@codingame/monaco-vscode-keybindings-service-override 2.2.2 → 3.0.0

package/keybindings.js

@@ -26,6 +26,7 @@ import getServiceOverride$1, { initFile } from '@codingame/monaco-vscode-files-s
 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';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-keybindings-service-override",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,14 +18,14 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@2.2.2",
+    "vscode": "npm:@codingame/monaco-vscode-api@3.0.0",
     "vscode-marked": "npm:marked@=3.0.2",
-    "@codingame/monaco-vscode-files-service-override": "2.2.2",
-    "@codingame/monaco-vscode-quickaccess-service-override": "2.2.2",
-    "@codingame/monaco-vscode-extensions-service-override": "2.2.2",
-    "@codingame/monaco-vscode-environment-service-override": "2.2.2",
-    "@codingame/monaco-vscode-layout-service-override": "2.2.2",
-    "@codingame/monaco-vscode-host-service-override": "2.2.2",
-    "@codingame/monaco-vscode-base-service-override": "2.2.2"
+    "@codingame/monaco-vscode-files-service-override": "3.0.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "3.0.0",
+    "@codingame/monaco-vscode-extensions-service-override": "3.0.0",
+    "@codingame/monaco-vscode-environment-service-override": "3.0.0",
+    "@codingame/monaco-vscode-layout-service-override": "3.0.0",
+    "@codingame/monaco-vscode-host-service-override": "3.0.0",
+    "@codingame/monaco-vscode-base-service-override": "3.0.0"
   }
 }

package/vscode/src/vs/workbench/browser/contextkeys.js

@@ -3,7 +3,7 @@ import { Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { setConstant, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IsMacContext, IsLinuxContext, IsWindowsContext, IsWebContext, IsMacNativeContext, IsIOSContext, IsMobileContext, IsDevelopmentContext, ProductQualityContext, InputFocusedContext } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
-import { RemoteNameContext, VirtualWorkspaceContext, TemporaryWorkspaceContext, HasWebFileSystemAccess, EmbedderIdentifierContext, ActiveEditorContext, ActiveEditorReadonlyContext, ActiveCompareEditorOriginalWriteableContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorAvailableEditorIdsContext, EditorsVisibleContext, TextCompareEditorVisibleContext, TextCompareEditorActiveContext, SideBySideEditorActiveContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, DirtyWorkingCopiesContext, WorkbenchStateContext, WorkspaceFolderCountContext, OpenFolderWorkspaceSupportContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, SplitEditorsVertically, IsMainWindowFullscreenContext, IsAuxiliaryWindowFocusedContext, InEditorZenModeContext, IsCenteredLayoutContext, MainEditorAreaVisibleContext, EditorTabsVisibleContext, SideBarVisibleContext, TitleBarVisibleContext, TitleBarStyleContext, PanelPositionContext, PanelVisibleContext, PanelMaximizedContext, PanelAlignmentContext, AuxiliaryBarVisibleContext, applyAvailableEditorIds } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { RemoteNameContext, VirtualWorkspaceContext, TemporaryWorkspaceContext, HasWebFileSystemAccess, EmbedderIdentifierContext, ActiveEditorContext, ActiveEditorReadonlyContext, ActiveCompareEditorOriginalWriteableContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorAvailableEditorIdsContext, EditorsVisibleContext, TextCompareEditorVisibleContext, TextCompareEditorActiveContext, SideBySideEditorActiveContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, MultipleEditorGroupsContext, DirtyWorkingCopiesContext, WorkbenchStateContext, WorkspaceFolderCountContext, OpenFolderWorkspaceSupportContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, SplitEditorsVertically, IsMainWindowFullscreenContext, IsAuxiliaryWindowFocusedContext, InEditorZenModeContext, IsMainEditorCenteredLayoutContext, MainEditorAreaVisibleContext, EditorTabsVisibleContext, SideBarVisibleContext, TitleBarVisibleContext, TitleBarStyleContext, PanelPositionContext, PanelVisibleContext, PanelMaximizedContext, PanelAlignmentContext, AuxiliaryBarVisibleContext, applyAvailableEditorIds } from 'vscode/vscode/vs/workbench/common/contextkeys';
 import { TEXT_DIFF_EDITOR_ID, SIDE_BY_SIDE_EDITOR_ID, EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
 import { onDidRegisterWindow, addDisposableListener, EventType, trackFocus, getActiveWindow } from 'vscode/vscode/vs/base/browser/dom';
 import { preferredSideBySideGroupDirection, IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
@@ -92,7 +92,7 @@ let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disp
         this.isMainWindowFullscreenContext = IsMainWindowFullscreenContext.bindTo(this.contextKeyService);
         this.isAuxiliaryWindowFocusedContext = IsAuxiliaryWindowFocusedContext.bindTo(this.contextKeyService);
         this.inZenModeContext = InEditorZenModeContext.bindTo(this.contextKeyService);
-        this.isCenteredLayoutContext = IsCenteredLayoutContext.bindTo(this.contextKeyService);
+        this.isMainEditorCenteredLayoutContext = IsMainEditorCenteredLayoutContext.bindTo(this.contextKeyService);
         this.mainEditorAreaVisibleContext = MainEditorAreaVisibleContext.bindTo(this.contextKeyService);
         this.editorTabsVisibleContext = EditorTabsVisibleContext.bindTo(this.contextKeyService);
         this.sideBarVisibleContext = SideBarVisibleContext.bindTo(this.contextKeyService);
@@ -142,7 +142,7 @@ let WorkbenchContextKeysHandler = class WorkbenchContextKeysHandler extends Disp
                 this.isMainWindowFullscreenContext.set(isFullscreen(mainWindow));
             }
         }));
-        this._register(this.layoutService.onDidChangeCenteredLayout(centered => this.isCenteredLayoutContext.set(centered)));
+        this._register(this.layoutService.onDidChangeMainEditorCenteredLayout(centered => this.isMainEditorCenteredLayoutContext.set(centered)));
         this._register(this.layoutService.onDidChangePanelPosition(position => this.panelPositionContext.set(position)));
         this._register(this.layoutService.onDidChangePanelAlignment(alignment => this.panelAlignmentContext.set(alignment)));
         this._register(this.paneCompositeService.onDidPaneCompositeClose(() => this.updateSideBarContextKeys()));

package/vscode/src/vs/workbench/contrib/commands/common/commands.contribution.js

@@ -1,4 +1,4 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
@@ -8,11 +8,11 @@ class RunCommands extends Action2 {
     constructor() {
         super({
             id: 'runCommands',
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/commands/common/commands.contribution',
                 'runCommands',
                 "Run Commands"
-            )), original: 'Run Commands' },
+            )),
             f1: false,
             metadata: {
                 description: ( localizeWithPath(

package/vscode/src/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js

@@ -1,4 +1,4 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
@@ -9,11 +9,11 @@ class ToggleKeybindingsLogAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.action.toggleKeybindingsLog',
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/keybindings/browser/keybindings.contribution',
                 'toggleKeybindingsLog',
                 "Toggle Keyboard Shortcuts Troubleshooting"
-            )), original: 'Toggle Keyboard Shortcuts Troubleshooting' },
+            )),
             category: Categories.Developer,
             f1: true
         });

package/vscode/src/vs/workbench/contrib/preferences/browser/keybindingsEditorContribution.js

@@ -0,0 +1,250 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { SnippetController2 } from 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+import { SmartSnippetInserter } from '../common/smartSnippetInserter.js';
+import { DefineKeybindingOverlayWidget } from 'vscode/vscode/vs/workbench/contrib/preferences/browser/keybindingWidgets';
+import { parseTree } from 'vscode/vscode/vs/base/common/json';
+import { WindowsNativeResolvedKeybinding } from '../../../services/keybinding/common/windowsKeyboardMapper.js';
+import { themeColorFromId } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { overviewRulerError, overviewRulerInfo } from 'vscode/vscode/vs/editor/common/core/editorColorRegistry';
+import { OverviewRulerLane } from 'vscode/vscode/vs/editor/common/model';
+import { KeybindingParser } from 'vscode/vscode/vs/base/common/keybindingParser';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { DEFINE_KEYBINDING_EDITOR_CONTRIB_ID } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+
+var KeybindingEditorDecorationsRenderer_1;
+const NLS_KB_LAYOUT_ERROR_MESSAGE = ( localizeWithPath(
+    'vs/workbench/contrib/preferences/browser/keybindingsEditorContribution',
+    'defineKeybinding.kbLayoutErrorMessage',
+    "You won't be able to produce this key combination under your current keyboard layout."
+));
+let DefineKeybindingEditorContribution = class DefineKeybindingEditorContribution extends Disposable {
+    constructor(_editor, _instantiationService, _userDataProfileService) {
+        super();
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._userDataProfileService = _userDataProfileService;
+        this._keybindingDecorationRenderer = this._register(( new MutableDisposable()));
+        this._defineWidget = this._register(this._instantiationService.createInstance(DefineKeybindingOverlayWidget, this._editor));
+        this._register(this._editor.onDidChangeModel(e => this._update()));
+        this._update();
+    }
+    _update() {
+        this._keybindingDecorationRenderer.value = isInterestingEditorModel(this._editor, this._userDataProfileService)
+            ? this._instantiationService.createInstance(KeybindingEditorDecorationsRenderer, this._editor)
+            : undefined;
+    }
+    showDefineKeybindingWidget() {
+        if (isInterestingEditorModel(this._editor, this._userDataProfileService)) {
+            this._defineWidget.start().then(keybinding => this._onAccepted(keybinding));
+        }
+    }
+    _onAccepted(keybinding) {
+        this._editor.focus();
+        if (keybinding && this._editor.hasModel()) {
+            const regexp = ( new RegExp(/\\/g));
+            const backslash = regexp.test(keybinding);
+            if (backslash) {
+                keybinding = keybinding.slice(0, -1) + '\\\\';
+            }
+            let snippetText = [
+                '{',
+                '\t"key": ' + JSON.stringify(keybinding) + ',',
+                '\t"command": "${1:commandId}",',
+                '\t"when": "${2:editorTextFocus}"',
+                '}$0'
+            ].join('\n');
+            const smartInsertInfo = SmartSnippetInserter.insertSnippet(this._editor.getModel(), this._editor.getPosition());
+            snippetText = smartInsertInfo.prepend + snippetText + smartInsertInfo.append;
+            this._editor.setPosition(smartInsertInfo.position);
+            SnippetController2.get(this._editor)?.insert(snippetText, { overwriteBefore: 0, overwriteAfter: 0 });
+        }
+    }
+};
+DefineKeybindingEditorContribution = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IUserDataProfileService))
+], DefineKeybindingEditorContribution));
+let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = class KeybindingEditorDecorationsRenderer extends Disposable {
+    constructor(_editor, _keybindingService) {
+        super();
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this._dec = this._editor.createDecorationsCollection();
+        this._updateDecorations = this._register(( new RunOnceScheduler(() => this._updateDecorationsNow(), 500)));
+        const model = assertIsDefined(this._editor.getModel());
+        this._register(model.onDidChangeContent(() => this._updateDecorations.schedule()));
+        this._register(this._keybindingService.onDidUpdateKeybindings(() => this._updateDecorations.schedule()));
+        this._register({
+            dispose: () => {
+                this._dec.clear();
+                this._updateDecorations.cancel();
+            }
+        });
+        this._updateDecorations.schedule();
+    }
+    _updateDecorationsNow() {
+        const model = assertIsDefined(this._editor.getModel());
+        const newDecorations = [];
+        const root = parseTree(model.getValue());
+        if (root && Array.isArray(root.children)) {
+            for (let i = 0, len = root.children.length; i < len; i++) {
+                const entry = root.children[i];
+                const dec = this._getDecorationForEntry(model, entry);
+                if (dec !== null) {
+                    newDecorations.push(dec);
+                }
+            }
+        }
+        this._dec.set(newDecorations);
+    }
+    _getDecorationForEntry(model, entry) {
+        if (!Array.isArray(entry.children)) {
+            return null;
+        }
+        for (let i = 0, len = entry.children.length; i < len; i++) {
+            const prop = entry.children[i];
+            if (prop.type !== 'property') {
+                continue;
+            }
+            if (!Array.isArray(prop.children) || prop.children.length !== 2) {
+                continue;
+            }
+            const key = prop.children[0];
+            if (key.value !== 'key') {
+                continue;
+            }
+            const value = prop.children[1];
+            if (value.type !== 'string') {
+                continue;
+            }
+            const resolvedKeybindings = this._keybindingService.resolveUserBinding(value.value);
+            if (resolvedKeybindings.length === 0) {
+                return this._createDecoration(true, null, null, model, value);
+            }
+            const resolvedKeybinding = resolvedKeybindings[0];
+            let usLabel = null;
+            if (resolvedKeybinding instanceof WindowsNativeResolvedKeybinding) {
+                usLabel = resolvedKeybinding.getUSLabel();
+            }
+            if (!resolvedKeybinding.isWYSIWYG()) {
+                const uiLabel = resolvedKeybinding.getLabel();
+                if (typeof uiLabel === 'string' && value.value.toLowerCase() === uiLabel.toLowerCase()) {
+                    return null;
+                }
+                return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
+            }
+            if (/abnt_|oem_/.test(value.value)) {
+                return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
+            }
+            const expectedUserSettingsLabel = resolvedKeybinding.getUserSettingsLabel();
+            if (typeof expectedUserSettingsLabel === 'string' && !KeybindingEditorDecorationsRenderer_1._userSettingsFuzzyEquals(value.value, expectedUserSettingsLabel)) {
+                return this._createDecoration(false, resolvedKeybinding.getLabel(), usLabel, model, value);
+            }
+            return null;
+        }
+        return null;
+    }
+    static _userSettingsFuzzyEquals(a, b) {
+        a = a.trim().toLowerCase();
+        b = b.trim().toLowerCase();
+        if (a === b) {
+            return true;
+        }
+        const aKeybinding = KeybindingParser.parseKeybinding(a);
+        const bKeybinding = KeybindingParser.parseKeybinding(b);
+        if (aKeybinding === null && bKeybinding === null) {
+            return true;
+        }
+        if (!aKeybinding || !bKeybinding) {
+            return false;
+        }
+        return aKeybinding.equals(bKeybinding);
+    }
+    _createDecoration(isError, uiLabel, usLabel, model, keyNode) {
+        let msg;
+        let className;
+        let overviewRulerColor;
+        if (isError) {
+            msg = ( new MarkdownString()).appendText(NLS_KB_LAYOUT_ERROR_MESSAGE);
+            className = 'keybindingError';
+            overviewRulerColor = themeColorFromId(overviewRulerError);
+        }
+        else {
+            if (usLabel && uiLabel !== usLabel) {
+                msg = ( new MarkdownString(( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keybindingsEditorContribution',
+                    {
+                        key: 'defineKeybinding.kbLayoutLocalAndUSMessage',
+                        comment: [
+                            'Please translate maintaining the stars (*) around the placeholders such that they will be rendered in bold.',
+                            'The placeholders will contain a keyboard combination e.g. Ctrl+Shift+/'
+                        ]
+                    },
+                    "**{0}** for your current keyboard layout (**{1}** for US standard).",
+                    uiLabel,
+                    usLabel
+                ))));
+            }
+            else {
+                msg = ( new MarkdownString(( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keybindingsEditorContribution',
+                    {
+                        key: 'defineKeybinding.kbLayoutLocalMessage',
+                        comment: [
+                            'Please translate maintaining the stars (*) around the placeholder such that it will be rendered in bold.',
+                            'The placeholder will contain a keyboard combination e.g. Ctrl+Shift+/'
+                        ]
+                    },
+                    "**{0}** for your current keyboard layout.",
+                    uiLabel
+                ))));
+            }
+            className = 'keybindingInfo';
+            overviewRulerColor = themeColorFromId(overviewRulerInfo);
+        }
+        const startPosition = model.getPositionAt(keyNode.offset);
+        const endPosition = model.getPositionAt(keyNode.offset + keyNode.length);
+        const range = ( new Range(
+            startPosition.lineNumber,
+            startPosition.column,
+            endPosition.lineNumber,
+            endPosition.column
+        ));
+        return {
+            range: range,
+            options: {
+                description: 'keybindings-widget',
+                stickiness: 1 ,
+                className: className,
+                hoverMessage: msg,
+                overviewRuler: {
+                    color: overviewRulerColor,
+                    position: OverviewRulerLane.Right
+                }
+            }
+        };
+    }
+};
+KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = ( __decorate([
+    ( __param(1, IKeybindingService))
+], KeybindingEditorDecorationsRenderer));
+function isInterestingEditorModel(editor, userDataProfileService) {
+    const model = editor.getModel();
+    if (!model) {
+        return false;
+    }
+    return isEqual(model.uri, userDataProfileService.currentProfile.keybindingsResource);
+}
+registerEditorContribution(DEFINE_KEYBINDING_EDITOR_CONTRIB_ID, DefineKeybindingEditorContribution, 1 );
+
+export { KeybindingEditorDecorationsRenderer };

package/vscode/src/vs/workbench/contrib/preferences/common/smartSnippetInserter.js

@@ -0,0 +1,126 @@
+import { createScanner } from 'vscode/vscode/vs/base/common/json';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+
+class SmartSnippetInserter {
+    static hasOpenBrace(scanner) {
+        while (scanner.scan() !== 17 ) {
+            const kind = scanner.getToken();
+            if (kind === 1 ) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static offsetToPosition(model, offset) {
+        let offsetBeforeLine = 0;
+        const eolLength = model.getEOL().length;
+        const lineCount = model.getLineCount();
+        for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+            const lineTotalLength = model.getLineLength(lineNumber) + eolLength;
+            const offsetAfterLine = offsetBeforeLine + lineTotalLength;
+            if (offsetAfterLine > offset) {
+                return ( new Position(lineNumber, offset - offsetBeforeLine + 1));
+            }
+            offsetBeforeLine = offsetAfterLine;
+        }
+        return ( new Position(lineCount, model.getLineMaxColumn(lineCount)));
+    }
+    static insertSnippet(model, _position) {
+        const desiredPosition = model.getValueLengthInRange(( new Range(1, 1, _position.lineNumber, _position.column)));
+        let State;
+        ( (function(State) {
+            State[State["INVALID"] = 0] = "INVALID";
+            State[State["AFTER_OBJECT"] = 1] = "AFTER_OBJECT";
+            State[State["BEFORE_OBJECT"] = 2] = "BEFORE_OBJECT";
+        })(State || (State = {})));
+        let currentState = State.INVALID;
+        let lastValidPos = -1;
+        let lastValidState = State.INVALID;
+        const scanner = createScanner(model.getValue());
+        let arrayLevel = 0;
+        let objLevel = 0;
+        const checkRangeStatus = (pos, state) => {
+            if (state !== State.INVALID && arrayLevel === 1 && objLevel === 0) {
+                currentState = state;
+                lastValidPos = pos;
+                lastValidState = state;
+            }
+            else {
+                if (currentState !== State.INVALID) {
+                    currentState = State.INVALID;
+                    lastValidPos = scanner.getTokenOffset();
+                }
+            }
+        };
+        while (scanner.scan() !== 17 ) {
+            const currentPos = scanner.getPosition();
+            const kind = scanner.getToken();
+            let goodKind = false;
+            switch (kind) {
+                case 3 :
+                    goodKind = true;
+                    arrayLevel++;
+                    checkRangeStatus(currentPos, State.BEFORE_OBJECT);
+                    break;
+                case 4 :
+                    goodKind = true;
+                    arrayLevel--;
+                    checkRangeStatus(currentPos, State.INVALID);
+                    break;
+                case 5 :
+                    goodKind = true;
+                    checkRangeStatus(currentPos, State.BEFORE_OBJECT);
+                    break;
+                case 1 :
+                    goodKind = true;
+                    objLevel++;
+                    checkRangeStatus(currentPos, State.INVALID);
+                    break;
+                case 2 :
+                    goodKind = true;
+                    objLevel--;
+                    checkRangeStatus(currentPos, State.AFTER_OBJECT);
+                    break;
+                case 15 :
+                case 14 :
+                    goodKind = true;
+            }
+            if (currentPos >= desiredPosition && (currentState !== State.INVALID || lastValidPos !== -1)) {
+                let acceptPosition;
+                let acceptState;
+                if (currentState !== State.INVALID) {
+                    acceptPosition = (goodKind ? currentPos : scanner.getTokenOffset());
+                    acceptState = currentState;
+                }
+                else {
+                    acceptPosition = lastValidPos;
+                    acceptState = lastValidState;
+                }
+                if (acceptState === State.AFTER_OBJECT) {
+                    return {
+                        position: this.offsetToPosition(model, acceptPosition),
+                        prepend: ',',
+                        append: ''
+                    };
+                }
+                else {
+                    scanner.setPosition(acceptPosition);
+                    return {
+                        position: this.offsetToPosition(model, acceptPosition),
+                        prepend: '',
+                        append: this.hasOpenBrace(scanner) ? ',' : ''
+                    };
+                }
+            }
+        }
+        const modelLineCount = model.getLineCount();
+        return {
+            position: ( new Position(modelLineCount, model.getLineMaxColumn(modelLineCount))),
+            prepend: '\n[',
+            append: ']'
+        };
+    }
+}
+
+export { SmartSnippetInserter };

package/vscode/src/vs/workbench/services/actions/common/menusExtensionPoint.js

@@ -1,13 +1,20 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { isFalsyOrWhitespace } from 'vscode/vscode/vs/base/common/strings';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { MenuId, MenuRegistry } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
 import { index } from 'vscode/vscode/vs/base/common/arrays';
 import { isProposedApiEnabled } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { platform } from 'vscode/vscode/vs/base/common/process';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
 
 const apiMenus = [
     {
@@ -141,6 +148,15 @@ const apiMenus = [
             "The debug toolbar menu"
         ))
     },
+    {
+        key: 'notebook/variables/context',
+        id: MenuId.NotebookVariablesContext,
+        description: ( localizeWithPath(
+            'vs/workbench/services/actions/common/menusExtensionPoint',
+            'menus.notebookVariablesContext',
+            "The notebook variables view context menu"
+        ))
+    },
     {
         key: 'menuBar/home',
         id: MenuId.MenubarHomeMenu,
@@ -179,6 +195,16 @@ const apiMenus = [
             "The Source Control menu"
         ))
     },
+    {
+        key: 'scm/sourceControl/title',
+        id: MenuId.SCMSourceControlTitle,
+        description: ( localizeWithPath(
+            'vs/workbench/services/actions/common/menusExtensionPoint',
+            'menus.scmSourceControlTitle',
+            "The Source Control title menu"
+        )),
+        proposed: 'contribSourceControlTitleMenu'
+    },
     {
         key: 'scm/resourceState/context',
         id: MenuId.SCMResourceContext,
@@ -235,6 +261,16 @@ const apiMenus = [
         )),
         proposed: 'contribSourceControlHistoryItemGroupMenu'
     },
+    {
+        key: 'scm/incomingChanges/context',
+        id: MenuId.SCMIncomingChangesContext,
+        description: ( localizeWithPath(
+            'vs/workbench/services/actions/common/menusExtensionPoint',
+            'menus.incomingChangesContext',
+            "The Source Control incoming changes context menu"
+        )),
+        proposed: 'contribSourceControlHistoryItemGroupMenu'
+    },
     {
         key: 'scm/outgoingChanges',
         id: MenuId.SCMOutgoingChanges,
@@ -245,6 +281,16 @@ const apiMenus = [
         )),
         proposed: 'contribSourceControlHistoryItemGroupMenu'
     },
+    {
+        key: 'scm/outgoingChanges/context',
+        id: MenuId.SCMOutgoingChangesContext,
+        description: ( localizeWithPath(
+            'vs/workbench/services/actions/common/menusExtensionPoint',
+            'menus.outgoingChangesContext',
+            "The Source Control outgoing changes context menu"
+        )),
+        proposed: 'contribSourceControlHistoryItemGroupMenu'
+    },
     {
         key: 'scm/incomingChanges/allChanges/context',
         id: MenuId.SCMIncomingChangesAllChangesContext,
@@ -465,6 +511,16 @@ const apiMenus = [
             "The contributed interactive cell title menu"
         )),
     },
+    {
+        key: 'issue/reporter',
+        id: MenuId.IssueReporter,
+        description: ( localizeWithPath(
+            'vs/workbench/services/actions/common/menusExtensionPoint',
+            'issue.reporter',
+            "The contributed issue reporter menu"
+        )),
+        proposed: 'contribIssueReporter'
+    },
     {
         key: 'testing/item/context',
         id: MenuId.TestItem,
@@ -595,6 +651,17 @@ const apiMenus = [
         supportsSubmenus: false,
         proposed: 'inlineCompletionsAdditions'
     },
+    {
+        key: 'editor/inlineEdit/actions',
+        id: MenuId.InlineEditActions,
+        description: ( localizeWithPath(
+            'vs/workbench/services/actions/common/menusExtensionPoint',
+            'inlineEdit.actions',
+            "The actions shown when hovering on an inline edit"
+        )),
+        supportsSubmenus: false,
+        proposed: 'inlineEdit'
+    },
     {
         key: 'editor/content',
         id: MenuId.EditorContent,
@@ -1103,7 +1170,7 @@ var schema;
     };
 })(schema || (schema = {})));
 const _commandRegistrations = ( new DisposableStore());
-const commandsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const commandsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'commands',
     jsonSchema: schema.commandsContribution,
     activationEventsGenerator: (contribs, result) => {
@@ -1113,7 +1180,7 @@ const commandsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
+});
 commandsExtensionPoint.setHandler(extensions => {
     function handleCommand(userFriendlyCommand, extension) {
         if (!schema.isValidCommand(userFriendlyCommand, extension.collector)) {
@@ -1178,10 +1245,10 @@ commandsExtensionPoint.setHandler(extensions => {
     }
 });
 const _submenus = ( new Map());
-const submenusExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const submenusExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'submenus',
     jsonSchema: schema.submenusContribution
-}));
+});
 submenusExtensionPoint.setHandler(extensions => {
     _submenus.clear();
     for (const extension of extensions) {
@@ -1241,11 +1308,11 @@ submenusExtensionPoint.setHandler(extensions => {
 const _apiMenusByKey = ( new Map(( apiMenus.map(menu => ([menu.key, menu])))));
 const _menuRegistrations = ( new DisposableStore());
 const _submenuMenuItems = ( new Map());
-const menusExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const menusExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'menus',
     jsonSchema: schema.menusContribution,
     deps: [submenusExtensionPoint]
-}));
+});
 menusExtensionPoint.setHandler(extensions => {
     _menuRegistrations.clear();
     _submenuMenuItems.clear();
@@ -1364,5 +1431,128 @@ menusExtensionPoint.setHandler(extensions => {
         }
     }
 });
+let CommandsTableRenderer = class CommandsTableRenderer extends Disposable {
+    constructor(_keybindingService) {
+        super();
+        this._keybindingService = _keybindingService;
+        this.type = 'table';
+    }
+    shouldRender(manifest) {
+        return !!manifest.contributes?.commands;
+    }
+    render(manifest) {
+        const rawCommands = manifest.contributes?.commands || [];
+        const commands = ( rawCommands.map(c => ({
+            id: c.command,
+            title: c.title,
+            keybindings: [],
+            menus: []
+        })));
+        const byId = index(commands, c => c.id);
+        const menus = manifest.contributes?.menus || {};
+        for (const context in menus) {
+            for (const menu of menus[context]) {
+                if (menu.command) {
+                    let command = byId[menu.command];
+                    if (command) {
+                        command.menus.push(context);
+                    }
+                    else {
+                        command = { id: menu.command, title: '', keybindings: [], menus: [context] };
+                        byId[command.id] = command;
+                        commands.push(command);
+                    }
+                }
+            }
+        }
+        const rawKeybindings = manifest.contributes?.keybindings ? (Array.isArray(manifest.contributes.keybindings) ? manifest.contributes.keybindings : [manifest.contributes.keybindings]) : [];
+        rawKeybindings.forEach(rawKeybinding => {
+            const keybinding = this.resolveKeybinding(rawKeybinding);
+            if (!keybinding) {
+                return;
+            }
+            let command = byId[rawKeybinding.command];
+            if (command) {
+                command.keybindings.push(keybinding);
+            }
+            else {
+                command = { id: rawKeybinding.command, title: '', keybindings: [keybinding], menus: [] };
+                byId[command.id] = command;
+                commands.push(command);
+            }
+        });
+        if (!commands.length) {
+            return { data: { headers: [], rows: [] }, dispose: () => { } };
+        }
+        const headers = [
+            ( localizeWithPath(
+                'vs/workbench/services/actions/common/menusExtensionPoint',
+                'command name',
+                "ID"
+            )),
+            ( localizeWithPath(
+                'vs/workbench/services/actions/common/menusExtensionPoint',
+                'command title',
+                "Title"
+            )),
+            ( localizeWithPath(
+                'vs/workbench/services/actions/common/menusExtensionPoint',
+                'keyboard shortcuts',
+                "Keyboard Shortcuts"
+            )),
+            ( localizeWithPath(
+                'vs/workbench/services/actions/common/menusExtensionPoint',
+                'menuContexts',
+                "Menu Contexts"
+            ))
+        ];
+        const rows = ( commands.sort((a, b) => a.id.localeCompare(b.id))
+            .map(command => {
+            return [
+                ( new MarkdownString()).appendMarkdown(`\`${command.id}\``),
+                typeof command.title === 'string' ? command.title : command.title.value,
+                command.keybindings,
+                ( new MarkdownString()).appendMarkdown(`${( command.menus.map(menu => `\`${menu}\``)).join(' ')}`),
+            ];
+        }));
+        return {
+            data: {
+                headers,
+                rows
+            },
+            dispose: () => { }
+        };
+    }
+    resolveKeybinding(rawKeyBinding) {
+        let key;
+        switch (platform) {
+            case 'win32':
+                key = rawKeyBinding.win;
+                break;
+            case 'linux':
+                key = rawKeyBinding.linux;
+                break;
+            case 'darwin':
+                key = rawKeyBinding.mac;
+                break;
+        }
+        return this._keybindingService.resolveUserBinding(key ?? rawKeyBinding.key)[0];
+    }
+};
+CommandsTableRenderer = ( __decorate([
+    ( __param(0, IKeybindingService))
+], CommandsTableRenderer));
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: 'commands',
+    label: ( localizeWithPath(
+        'vs/workbench/services/actions/common/menusExtensionPoint',
+        'commands',
+        "Commands"
+    )),
+    access: {
+        canToggle: false,
+    },
+    renderer: ( new SyncDescriptor(CommandsTableRenderer)),
+});
 
 export { commandsExtensionPoint };

package/vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js

@@ -167,7 +167,7 @@ const keybindingType = {
         },
     }
 };
-const keybindingsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const keybindingsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'keybindings',
     deps: [commandsExtensionPoint],
     jsonSchema: {
@@ -184,7 +184,7 @@ const keybindingsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         ]
     }
-}));
+});
 const NUMPAD_PRINTABLE_SCANCODES = [
     90 ,
     91 ,