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

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
@@ -6,24 +7,24 @@ import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/life
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
 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 { registerEditorContribution, EditorContributionInstantiation } 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 { DefineKeybindingOverlayWidget } from '@codingame/monaco-vscode-d609a7d3-bf87-551a-884f-550a8b327ec5-common/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 { TrackedRangeStickiness, OverviewRulerLane } from 'vscode/vscode/vs/editor/common/model';
+import { KeybindingParser } from '@codingame/monaco-vscode-2a22c7b4-b906-5914-8cd1-3ed912fb738f-common/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.service';
-import { DEFINE_KEYBINDING_EDITOR_CONTRIB_ID } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { DEFINE_KEYBINDING_EDITOR_CONTRIB_ID } from '@codingame/monaco-vscode-4a36e358-d94d-55e0-86ee-3bcd543d9d3f-common/vscode/vs/workbench/services/preferences/common/preferences';
 
 var KeybindingEditorDecorationsRenderer_1;
 const NLS_KB_LAYOUT_ERROR_MESSAGE = ( localize(
-    3559,
+    7912,
     "You won't be able to produce this key combination under your current keyboard layout."
 ));
 let DefineKeybindingEditorContribution = class DefineKeybindingEditorContribution extends Disposable {
@@ -32,7 +33,7 @@ let DefineKeybindingEditorContribution = class DefineKeybindingEditorContributio
         this._editor = _editor;
         this._instantiationService = _instantiationService;
         this._userDataProfileService = _userDataProfileService;
-        this._keybindingDecorationRenderer = this._register(( (new MutableDisposable())));
+        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();
@@ -50,7 +51,7 @@ let DefineKeybindingEditorContribution = class DefineKeybindingEditorContributio
     _onAccepted(keybinding) {
         this._editor.focus();
         if (keybinding && this._editor.hasModel()) {
-            const regexp = ( (new RegExp(/\\/g)));
+            const regexp = ( new RegExp(/\\/g));
             const backslash = regexp.test(keybinding);
             if (backslash) {
                 keybinding = keybinding.slice(0, -1) + '\\\\';
@@ -69,17 +70,17 @@ let DefineKeybindingEditorContribution = class DefineKeybindingEditorContributio
         }
     }
 };
-DefineKeybindingEditorContribution = ( (__decorate([
-    ( (__param(1, IInstantiationService))),
-    ( (__param(2, IUserDataProfileService)))
-], DefineKeybindingEditorContribution)));
+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))));
+        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()));
@@ -174,38 +175,38 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         let className;
         let overviewRulerColor;
         if (isError) {
-            msg = ( (new MarkdownString())).appendText(NLS_KB_LAYOUT_ERROR_MESSAGE);
+            msg = ( new MarkdownString()).appendText(NLS_KB_LAYOUT_ERROR_MESSAGE);
             className = 'keybindingError';
             overviewRulerColor = themeColorFromId(overviewRulerError);
         }
         else {
             if (usLabel && uiLabel !== usLabel) {
-                msg = ( (new MarkdownString(( localize(
-                    3560,
+                msg = ( new MarkdownString(( localize(
+                    7913,
                     "**{0}** for your current keyboard layout (**{1}** for US standard).",
                     uiLabel,
                     usLabel
-                )))));
+                ))));
             }
             else {
-                msg = ( (new MarkdownString(( localize(3561, "**{0}** for your current keyboard layout.", uiLabel)))));
+                msg = ( new MarkdownString(( localize(7914, "**{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(
+        const range = ( new Range(
             startPosition.lineNumber,
             startPosition.column,
             endPosition.lineNumber,
             endPosition.column
-        )));
+        ));
         return {
             range: range,
             options: {
                 description: 'keybindings-widget',
-                stickiness: 1 ,
+                stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
                 className: className,
                 hoverMessage: msg,
                 overviewRuler: {
@@ -216,9 +217,9 @@ let KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1
         };
     }
 };
-KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = ( (__decorate([
-    ( (__param(1, IKeybindingService)))
-], KeybindingEditorDecorationsRenderer)));
+KeybindingEditorDecorationsRenderer = KeybindingEditorDecorationsRenderer_1 = ( __decorate([
+    ( __param(1, IKeybindingService))
+], KeybindingEditorDecorationsRenderer));
 function isInterestingEditorModel(editor, userDataProfileService) {
     const model = editor.getModel();
     if (!model) {
@@ -226,6 +227,6 @@ function isInterestingEditorModel(editor, userDataProfileService) {
     }
     return isEqual(model.uri, userDataProfileService.currentProfile.keybindingsResource);
 }
-registerEditorContribution(DEFINE_KEYBINDING_EDITOR_CONTRIB_ID, DefineKeybindingEditorContribution, 1 );
+registerEditorContribution(DEFINE_KEYBINDING_EDITOR_CONTRIB_ID, DefineKeybindingEditorContribution, EditorContributionInstantiation.AfterFirstRender);
 
 export { KeybindingEditorDecorationsRenderer };

package/vscode/src/vs/workbench/contrib/preferences/common/smartSnippetInserter.d.ts

@@ -0,0 +1,12 @@
+import { Position } from "vscode/vscode/vs/editor/common/core/position";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+export interface InsertSnippetResult {
+    position: Position;
+    prepend: string;
+    append: string;
+}
+export declare class SmartSnippetInserter {
+    private static hasOpenBrace;
+    private static offsetToPosition;
+    static insertSnippet(model: ITextModel, _position: Position): InsertSnippetResult;
+}

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

@@ -1,12 +1,13 @@
-import { createScanner } from 'vscode/vscode/vs/base/common/json';
+
+import { SyntaxKind, 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 ) {
+        while (scanner.scan() !== SyntaxKind.EOF) {
             const kind = scanner.getToken();
-            if (kind === 1 ) {
+            if (kind === SyntaxKind.OpenBraceToken) {
                 return true;
             }
         }
@@ -29,11 +30,11 @@ class SmartSnippetInserter {
     static insertSnippet(model, _position) {
         const desiredPosition = model.getValueLengthInRange(( new Range(1, 1, _position.lineNumber, _position.column)));
         let State;
-        ( (function(State) {
+        (function (State) {
             State[State["INVALID"] = 0] = "INVALID";
             State[State["AFTER_OBJECT"] = 1] = "AFTER_OBJECT";
             State[State["BEFORE_OBJECT"] = 2] = "BEFORE_OBJECT";
-        })(State || (State = {})));
+        })(State || (State = {}));
         let currentState = State.INVALID;
         let lastValidPos = -1;
         let lastValidState = State.INVALID;
@@ -53,37 +54,37 @@ class SmartSnippetInserter {
                 }
             }
         };
-        while (scanner.scan() !== 17 ) {
+        while (scanner.scan() !== SyntaxKind.EOF) {
             const currentPos = scanner.getPosition();
             const kind = scanner.getToken();
             let goodKind = false;
             switch (kind) {
-                case 3 :
+                case SyntaxKind.OpenBracketToken:
                     goodKind = true;
                     arrayLevel++;
                     checkRangeStatus(currentPos, State.BEFORE_OBJECT);
                     break;
-                case 4 :
+                case SyntaxKind.CloseBracketToken:
                     goodKind = true;
                     arrayLevel--;
                     checkRangeStatus(currentPos, State.INVALID);
                     break;
-                case 5 :
+                case SyntaxKind.CommaToken:
                     goodKind = true;
                     checkRangeStatus(currentPos, State.BEFORE_OBJECT);
                     break;
-                case 1 :
+                case SyntaxKind.OpenBraceToken:
                     goodKind = true;
                     objLevel++;
                     checkRangeStatus(currentPos, State.INVALID);
                     break;
-                case 2 :
+                case SyntaxKind.CloseBraceToken:
                     goodKind = true;
                     objLevel--;
                     checkRangeStatus(currentPos, State.AFTER_OBJECT);
                     break;
-                case 15 :
-                case 14 :
+                case SyntaxKind.Trivia:
+                case SyntaxKind.LineBreakTrivia:
                     goodKind = true;
             }
             if (currentPos >= desiredPosition && (currentState !== State.INVALID || lastValidPos !== -1)) {

package/vscode/src/vs/workbench/services/actions/common/menusExtensionPoint.d.ts

@@ -0,0 +1,44 @@
+import { IJSONSchema } from "vscode/vscode/vs/base/common/jsonSchema";
+import { ExtensionMessageCollector } from "vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry";
+import { ILocalizedString } from "vscode/vscode/vs/platform/action/common/action";
+declare namespace schema {
+    interface IUserFriendlyMenuItem {
+        command: string;
+        alt?: string;
+        when?: string;
+        group?: string;
+    }
+    interface IUserFriendlySubmenuItem {
+        submenu: string;
+        when?: string;
+        group?: string;
+    }
+    interface IUserFriendlySubmenu {
+        id: string;
+        label: string;
+        icon?: IUserFriendlyIcon;
+    }
+    function isMenuItem(item: IUserFriendlyMenuItem | IUserFriendlySubmenuItem): item is IUserFriendlyMenuItem;
+    function isValidMenuItem(item: IUserFriendlyMenuItem, collector: ExtensionMessageCollector): boolean;
+    function isValidSubmenuItem(item: IUserFriendlySubmenuItem, collector: ExtensionMessageCollector): boolean;
+    function isValidItems(items: (IUserFriendlyMenuItem | IUserFriendlySubmenuItem)[], collector: ExtensionMessageCollector): boolean;
+    function isValidSubmenu(submenu: IUserFriendlySubmenu, collector: ExtensionMessageCollector): boolean;
+    const menusContribution: IJSONSchema;
+    const submenusContribution: IJSONSchema;
+    interface IUserFriendlyCommand {
+        command: string;
+        title: string | ILocalizedString;
+        shortTitle?: string | ILocalizedString;
+        enablement?: string;
+        category?: string | ILocalizedString;
+        icon?: IUserFriendlyIcon;
+    }
+    type IUserFriendlyIcon = string | {
+        light: string;
+        dark: string;
+    };
+    function isValidCommand(command: IUserFriendlyCommand, collector: ExtensionMessageCollector): boolean;
+    const commandsContribution: IJSONSchema;
+}
+export declare const commandsExtensionPoint: import("vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry").IExtensionPoint<schema.IUserFriendlyCommand | schema.IUserFriendlyCommand[]>;
+export {};