@codingame/monaco-vscode-api 2.2.2 → 3.0.0

package/vscode/src/vs/editor/contrib/rename/browser/renameInputField.js

@@ -1,10 +1,21 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { addDisposableListener, getClientArea, getDomNodePagePosition, getTotalHeight, getTotalWidth } from '../../../../base/browser/dom.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { renderIcon } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { List } from '../../../../base/browser/ui/list/listWidget.js';
+import { distinct } from '../../../../base/common/arrays.js';
+import { raceCancellation } from '../../../../base/common/async.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { assertType, isDefined } from '../../../../base/common/types.js';
 import './renameInputField.css.js';
 import { Position } from '../../../common/core/position.js';
+import '../../../common/languages.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { defaultListStyles } from '../../../../platform/theme/browser/defaultStyles.js';
 import { widgetShadow, widgetBorder, editorWidgetBackground, inputForeground, inputBackground, inputBorder } from '../../../../platform/theme/common/colorRegistry.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.js';
 const CONTEXT_RENAME_INPUT_VISIBLE = ( new RawContextKey('renameInputVisible', false, ( localizeWithPath(
@@ -12,15 +23,22 @@ const CONTEXT_RENAME_INPUT_VISIBLE = ( new RawContextKey('renameInputVisible', f
     'renameInputVisible',
     "Whether the rename input widget is visible"
 ))));
+const CONTEXT_RENAME_INPUT_FOCUSED = ( new RawContextKey('renameInputFocused', false, ( localizeWithPath(
+    'vs/editor/contrib/rename/browser/renameInputField',
+    'renameInputFocused',
+    "Whether the rename input widget is focused"
+))));
 let RenameInputField = class RenameInputField {
-    constructor(_editor, _acceptKeybindings, _themeService, _keybindingService, contextKeyService) {
+    constructor(_editor, _acceptKeybindings, _themeService, _keybindingService, contextKeyService, _logService) {
         this._editor = _editor;
         this._acceptKeybindings = _acceptKeybindings;
         this._themeService = _themeService;
         this._keybindingService = _keybindingService;
+        this._logService = _logService;
         this._disposables = ( new DisposableStore());
         this.allowEditorOverflow = true;
         this._visibleContextKey = CONTEXT_RENAME_INPUT_VISIBLE.bindTo(contextKeyService);
+        this._focusedContextKey = CONTEXT_RENAME_INPUT_FOCUSED.bindTo(contextKeyService);
         this._editor.addContentWidget(this);
         this._disposables.add(this._editor.onDidChangeConfiguration(e => {
             if (e.hasChanged(50 )) {
@@ -48,7 +66,13 @@ let RenameInputField = class RenameInputField {
                 'renameAriaLabel',
                 "Rename input. Type new name and press Enter to commit."
             )));
+            this._disposables.add(addDisposableListener(this._input, 'focus', () => { this._focusedContextKey.set(true); }));
+            this._disposables.add(addDisposableListener(this._input, 'blur', () => { this._focusedContextKey.reset(); }));
             this._domNode.appendChild(this._input);
+            this._candidatesView = this._disposables.add(( new CandidatesView(this._domNode, {
+                fontInfo: this._editor.getOption(50 ),
+                onSelectionChange: () => this.acceptInput(false)
+            })));
             this._label = document.createElement('div');
             this._label.className = 'rename-label';
             this._domNode.appendChild(this._label);
@@ -74,22 +98,41 @@ let RenameInputField = class RenameInputField {
         this._input.style.borderColor = border?.toString() ?? 'none';
     }
     _updateFont() {
-        if (!this._input || !this._label) {
+        if (!this._input || !this._label || !this._candidatesView) {
             return;
         }
         const fontInfo = this._editor.getOption(50 );
         this._input.style.fontFamily = fontInfo.fontFamily;
         this._input.style.fontWeight = fontInfo.fontWeight;
         this._input.style.fontSize = `${fontInfo.fontSize}px`;
-        this._label.style.fontSize = `${fontInfo.fontSize * 0.8}px`;
+        this._candidatesView.updateFont(fontInfo);
+        this._label.style.fontSize = `${this._computeLabelFontSize(fontInfo.fontSize)}px`;
+    }
+    _computeLabelFontSize(editorFontSize) {
+        return editorFontSize * 0.8;
     }
     getPosition() {
         if (!this._visible) {
             return null;
         }
+        if (!this._editor.hasModel() ||
+            !this._editor.getDomNode()
+        ) {
+            return null;
+        }
+        const bodyBox = getClientArea(this.getDomNode().ownerDocument.body);
+        const editorBox = getDomNodePagePosition(this._editor.getDomNode());
+        const cursorBoxTop = this._getTopForPosition();
+        this._nPxAvailableAbove = cursorBoxTop + editorBox.top;
+        this._nPxAvailableBelow = bodyBox.height - this._nPxAvailableAbove;
+        const lineHeight = this._editor.getOption(67 );
+        const { totalHeight: candidateViewHeight } = CandidateView.getLayoutInfo({ lineHeight });
+        const positionPreference = this._nPxAvailableBelow > candidateViewHeight * 6
+            ? [2 , 1 ]
+            : [1 , 2 ];
         return {
             position: this._position,
-            preference: [2 , 1 ]
+            preference: positionPreference,
         };
     }
     beforeRender() {
@@ -101,20 +144,54 @@ let RenameInputField = class RenameInputField {
             this._keybindingService.lookupKeybinding(accept)?.getLabel(),
             this._keybindingService.lookupKeybinding(preview)?.getLabel()
         ));
+        this._domNode.style.minWidth = `200px`;
         return null;
     }
     afterRender(position) {
-        if (!position) {
-            this.cancelInput(true);
+        this._trace('invoking afterRender, position: ', position ? 'not null' : 'null');
+        if (position === null) {
+            this.cancelInput(true, 'afterRender (because position is null)');
+            return;
+        }
+        if (!this._editor.hasModel() ||
+            !this._editor.getDomNode()
+        ) {
+            return;
+        }
+        assertType(this._candidatesView);
+        assertType(this._nPxAvailableAbove !== undefined);
+        assertType(this._nPxAvailableBelow !== undefined);
+        const inputBoxHeight = getTotalHeight(this._input);
+        const labelHeight = getTotalHeight(this._label);
+        let totalHeightAvailable;
+        if (position === 2 ) {
+            totalHeightAvailable = this._nPxAvailableBelow;
+        }
+        else {
+            totalHeightAvailable = this._nPxAvailableAbove;
         }
+        this._candidatesView.layout({
+            height: totalHeightAvailable - labelHeight - inputBoxHeight,
+            width: getTotalWidth(this._input),
+        });
     }
     acceptInput(wantsPreview) {
+        this._trace(`invoking acceptInput`);
         this._currentAcceptInput?.(wantsPreview);
     }
-    cancelInput(focusEditor) {
+    cancelInput(focusEditor, caller) {
+        this._trace(`invoking cancelInput, caller: ${caller}, _currentCancelInput: ${this._currentAcceptInput ? 'not undefined' : 'undefined'}`);
         this._currentCancelInput?.(focusEditor);
     }
-    getInput(where, value, selectionStart, selectionEnd, supportPreview, token) {
+    focusNextRenameSuggestion() {
+        this._candidatesView?.focusNext();
+    }
+    focusPreviousRenameSuggestion() {
+        if (!this._candidatesView?.focusPrevious()) {
+            this._input.focus();
+        }
+    }
+    getInput(where, value, selectionStart, selectionEnd, supportPreview, candidates, cts) {
         this._domNode.classList.toggle('preview', supportPreview);
         this._position = ( new Position(where.startLineNumber, where.startColumn));
         this._input.value = value;
@@ -122,27 +199,53 @@ let RenameInputField = class RenameInputField {
         this._input.setAttribute('selectionEnd', ( selectionEnd.toString()));
         this._input.size = Math.max((where.endColumn - where.startColumn) * 1.1, 20);
         const disposeOnDone = ( new DisposableStore());
+        disposeOnDone.add(toDisposable(() => cts.dispose(true)));
+        this._updateRenameCandidates(candidates, value, cts.token);
         return ( new Promise(resolve => {
             this._currentCancelInput = (focusEditor) => {
+                this._trace('invoking _currentCancelInput');
                 this._currentAcceptInput = undefined;
                 this._currentCancelInput = undefined;
+                this._candidatesView?.clearCandidates();
                 resolve(focusEditor);
                 return true;
             };
             this._currentAcceptInput = (wantsPreview) => {
-                if (this._input.value.trim().length === 0 || this._input.value === value) {
-                    this.cancelInput(true);
+                this._trace('invoking _currentAcceptInput');
+                assertType(this._input !== undefined);
+                assertType(this._candidatesView !== undefined);
+                const nRenameSuggestions = this._candidatesView.nCandidates;
+                let newName;
+                let source;
+                const focusedCandidate = this._candidatesView.focusedCandidate;
+                if (focusedCandidate !== undefined) {
+                    this._trace('using new name from renameSuggestion');
+                    newName = focusedCandidate;
+                    source = 'renameSuggestion';
+                }
+                else {
+                    this._trace('using new name from inputField');
+                    newName = this._input.value;
+                    source = 'inputField';
+                }
+                if (newName === value || newName.trim().length === 0 ) {
+                    this.cancelInput(true, '_currentAcceptInput (because newName === value || newName.trim().length === 0)');
                     return;
                 }
                 this._currentAcceptInput = undefined;
                 this._currentCancelInput = undefined;
+                this._candidatesView.clearCandidates();
                 resolve({
-                    newName: this._input.value,
-                    wantsPreview: supportPreview && wantsPreview
+                    newName,
+                    wantsPreview: supportPreview && wantsPreview,
+                    source,
+                    nRenameSuggestions,
                 });
             };
-            disposeOnDone.add(token.onCancellationRequested(() => this.cancelInput(true)));
-            disposeOnDone.add(this._editor.onDidBlurEditorWidget(() => this.cancelInput(!this._domNode?.ownerDocument.hasFocus())));
+            disposeOnDone.add(cts.token.onCancellationRequested(() => this.cancelInput(true, 'cts.token.onCancellationRequested')));
+            {
+                disposeOnDone.add(this._editor.onDidBlurEditorWidget(() => this.cancelInput(!this._domNode?.ownerDocument.hasFocus(), 'editor.onDidBlurEditorWidget')));
+            }
             this._show();
         })).finally(() => {
             disposeOnDone.dispose();
@@ -150,6 +253,7 @@ let RenameInputField = class RenameInputField {
         });
     }
     _show() {
+        this._trace('invoking _show');
         this._editor.revealLineInCenterIfOutsideViewport(this._position.lineNumber, 0 );
         this._visible = true;
         this._visibleContextKey.set(true);
@@ -159,15 +263,241 @@ let RenameInputField = class RenameInputField {
             this._input.setSelectionRange(parseInt(this._input.getAttribute('selectionStart')), parseInt(this._input.getAttribute('selectionEnd')));
         }, 100);
     }
+    async _updateRenameCandidates(candidates, currentName, token) {
+        const trace = (...args) => this._trace('_updateRenameCandidates', ...args);
+        trace('start');
+        const namesListResults = await raceCancellation(Promise.allSettled(candidates), token);
+        if (namesListResults === undefined) {
+            trace('returning early - received updateRenameCandidates results - undefined');
+            return;
+        }
+        const newNames = namesListResults.flatMap(namesListResult => namesListResult.status === 'fulfilled' && isDefined(namesListResult.value)
+            ? namesListResult.value
+            : []);
+        trace(`received updateRenameCandidates results - total (unfiltered) ${newNames.length} candidates.`);
+        const distinctNames = distinct(newNames, v => v.newSymbolName);
+        trace(`distinct candidates - ${distinctNames.length} candidates.`);
+        const validDistinctNames = distinctNames.filter(({ newSymbolName }) => newSymbolName.trim().length > 0 && newSymbolName !== this._input?.value && newSymbolName !== currentName);
+        trace(`valid distinct candidates - ${newNames.length} candidates.`);
+        if (validDistinctNames.length < 1) {
+            trace('returning early - no valid distinct candidates');
+            return;
+        }
+        trace('setting candidates');
+        this._candidatesView.setCandidates(validDistinctNames);
+        trace('asking editor to re-layout');
+        this._editor.layoutContentWidget(this);
+    }
     _hide() {
+        this._trace('invoked _hide');
         this._visible = false;
         this._visibleContextKey.reset();
         this._editor.layoutContentWidget(this);
     }
+    _getTopForPosition() {
+        const visibleRanges = this._editor.getVisibleRanges();
+        let firstLineInViewport;
+        if (visibleRanges.length > 0) {
+            firstLineInViewport = visibleRanges[0].startLineNumber;
+        }
+        else {
+            this._logService.warn('RenameInputField#_getTopForPosition: this should not happen - visibleRanges is empty');
+            firstLineInViewport = Math.max(1, this._position.lineNumber - 5);
+        }
+        return this._editor.getTopForLineNumber(this._position.lineNumber) - this._editor.getTopForLineNumber(firstLineInViewport);
+    }
+    _trace(...args) {
+        this._logService.trace('RenameInputField', ...args);
+    }
 };
 RenameInputField = ( __decorate([
     ( __param(2, IThemeService)),
     ( __param(3, IKeybindingService)),
-    ( __param(4, IContextKeyService))
+    ( __param(4, IContextKeyService)),
+    ( __param(5, ILogService))
 ], RenameInputField));
-export { CONTEXT_RENAME_INPUT_VISIBLE, RenameInputField };
+class CandidatesView {
+    constructor(parent, opts) {
+        this._disposables = ( new DisposableStore());
+        this._availableHeight = 0;
+        this._minimumWidth = 0;
+        this._lineHeight = opts.fontInfo.lineHeight;
+        this._typicalHalfwidthCharacterWidth = opts.fontInfo.typicalHalfwidthCharacterWidth;
+        this._listContainer = document.createElement('div');
+        this._listContainer.style.fontFamily = opts.fontInfo.fontFamily;
+        this._listContainer.style.fontWeight = opts.fontInfo.fontWeight;
+        this._listContainer.style.fontSize = `${opts.fontInfo.fontSize}px`;
+        parent.appendChild(this._listContainer);
+        const that = this;
+        const virtualDelegate = new class {
+            getTemplateId(element) {
+                return 'candidate';
+            }
+            getHeight(element) {
+                return that._candidateViewHeight;
+            }
+        };
+        const renderer = new (class {
+            constructor() {
+                this.templateId = 'candidate';
+            }
+            renderTemplate(container) {
+                return ( new CandidateView(container, { lineHeight: that._lineHeight }));
+            }
+            renderElement(candidate, index, templateData) {
+                templateData.model = candidate;
+            }
+            disposeTemplate(templateData) {
+                templateData.dispose();
+            }
+        });
+        this._listWidget = ( new List(
+            'NewSymbolNameCandidates',
+            this._listContainer,
+            virtualDelegate,
+            [renderer],
+            {
+                keyboardSupport: false,
+                mouseSupport: true,
+                multipleSelectionSupport: false,
+            }
+        ));
+        this._disposables.add(this._listWidget.onDidChangeSelection(e => {
+            if (e.elements.length > 0) {
+                opts.onSelectionChange();
+            }
+        }));
+        this._disposables.add(this._listWidget.onDidBlur(e => {
+            this._listWidget.setFocus([]);
+        }));
+        this._listWidget.style(defaultListStyles);
+    }
+    dispose() {
+        this._listWidget.dispose();
+        this._disposables.dispose();
+    }
+    layout({ height, width }) {
+        this._availableHeight = height;
+        this._minimumWidth = width;
+    }
+    setCandidates(candidates) {
+        this._listWidget.splice(0, 0, candidates);
+        const height = this._pickListHeight(candidates.length);
+        const width = this._pickListWidth(candidates);
+        this._listWidget.layout(height, width);
+        this._listContainer.style.height = `${height}px`;
+        this._listContainer.style.width = `${width}px`;
+        status(( localizeWithPath(
+            'vs/editor/contrib/rename/browser/renameInputField',
+            'renameSuggestionsReceivedAria',
+            "Received {0} rename suggestions",
+            candidates.length
+        )));
+    }
+    clearCandidates() {
+        this._listContainer.style.height = '0px';
+        this._listContainer.style.width = '0px';
+        this._listWidget.splice(0, this._listWidget.length, []);
+    }
+    get nCandidates() {
+        return this._listWidget.length;
+    }
+    get focusedCandidate() {
+        if (this._listWidget.length === 0) {
+            return;
+        }
+        const selectedElement = this._listWidget.getSelectedElements()[0];
+        if (selectedElement !== undefined) {
+            return selectedElement.newSymbolName;
+        }
+        const focusedElement = this._listWidget.getFocusedElements()[0];
+        if (focusedElement !== undefined) {
+            return focusedElement.newSymbolName;
+        }
+        return;
+    }
+    updateFont(fontInfo) {
+        this._listContainer.style.fontFamily = fontInfo.fontFamily;
+        this._listContainer.style.fontWeight = fontInfo.fontWeight;
+        this._listContainer.style.fontSize = `${fontInfo.fontSize}px`;
+        this._lineHeight = fontInfo.lineHeight;
+        this._listWidget.rerender();
+    }
+    focusNext() {
+        if (this._listWidget.length === 0) {
+            return;
+        }
+        if (this._listWidget.isDOMFocused()) {
+            this._listWidget.focusNext();
+        }
+        else {
+            this._listWidget.domFocus();
+            this._listWidget.focusFirst();
+        }
+        this._listWidget.reveal(this._listWidget.getFocus()[0]);
+    }
+    focusPrevious() {
+        if (this._listWidget.length === 0) {
+            return false;
+        }
+        this._listWidget.domFocus();
+        const focusedIx = this._listWidget.getFocus()[0];
+        if (focusedIx !== 0) {
+            this._listWidget.focusPrevious();
+            this._listWidget.reveal(this._listWidget.getFocus()[0]);
+        }
+        return focusedIx > 0;
+    }
+    get _candidateViewHeight() {
+        const { totalHeight } = CandidateView.getLayoutInfo({ lineHeight: this._lineHeight });
+        return totalHeight;
+    }
+    _pickListHeight(nCandidates) {
+        const heightToFitAllCandidates = this._candidateViewHeight * nCandidates;
+        const MAX_N_CANDIDATES = 7;
+        const height = Math.min(heightToFitAllCandidates, this._availableHeight, this._candidateViewHeight * MAX_N_CANDIDATES);
+        return height;
+    }
+    _pickListWidth(candidates) {
+        const longestCandidateWidth = Math.ceil(Math.max(...( candidates.map(c => c.newSymbolName.length))) * this._typicalHalfwidthCharacterWidth);
+        const width = Math.max(this._minimumWidth, 4  + 16  + 5  + longestCandidateWidth + 10
+        );
+        return width;
+    }
+}
+class CandidateView {
+    static { this._PADDING = 2; }
+    constructor(parent, { lineHeight }) {
+        this.domNode = document.createElement('div');
+        this.domNode.style.display = `flex`;
+        this.domNode.style.alignItems = `center`;
+        this.domNode.style.height = `${lineHeight}px`;
+        this.domNode.style.padding = `${CandidateView._PADDING}px`;
+        this._icon = document.createElement('div');
+        this._icon.style.display = `flex`;
+        this._icon.style.alignItems = `center`;
+        this._icon.style.width = this._icon.style.height = `${lineHeight * 0.8}px`;
+        this.domNode.appendChild(this._icon);
+        this._label = document.createElement('div');
+        this._icon.style.display = `flex`;
+        this._icon.style.alignItems = `center`;
+        this._label.style.marginLeft = '5px';
+        this.domNode.appendChild(this._label);
+        parent.appendChild(this.domNode);
+    }
+    set model(value) {
+        {
+            if (this._icon.children.length === 0) {
+                this._icon.appendChild(renderIcon(Codicon.sparkle));
+            }
+        }
+        this._label.innerText = value.newSymbolName;
+    }
+    static getLayoutInfo({ lineHeight }) {
+        const totalHeight = lineHeight + CandidateView._PADDING * 2 ;
+        return { totalHeight };
+    }
+    dispose() {
+    }
+}
+export { CONTEXT_RENAME_INPUT_FOCUSED, CONTEXT_RENAME_INPUT_VISIBLE, RenameInputField };

package/vscode/src/vs/editor/contrib/smartSelect/browser/smartSelect.js

@@ -55,7 +55,7 @@ let SmartSelectController = class SmartSelectController {
         const selections = this._editor.getSelections();
         const model = this._editor.getModel();
         if (!this._state) {
-            await provideSelectionRanges(this._languageFeaturesService.selectionRangeProvider, model, ( selections.map(s => s.getPosition())), this._editor.getOption(112 ), CancellationToken.None).then(ranges => {
+            await provideSelectionRanges(this._languageFeaturesService.selectionRangeProvider, model, ( selections.map(s => s.getPosition())), this._editor.getOption(113 ), CancellationToken.None).then(ranges => {
                 if (!isNonEmptyArray(ranges) || ranges.length !== selections.length) {
                     return;
                 }

package/vscode/src/vs/editor/contrib/snippet/browser/snippetSession.js

@@ -351,7 +351,7 @@ let SnippetSession = SnippetSession_1 = class SnippetSession {
                     readClipboardText,
                     idx,
                     indexedSelections.length,
-                    editor.getOption(78 ) === 'spread'
+                    editor.getOption(79 ) === 'spread'
                 )),
                 ( new SelectionBasedVariableResolver(model, selection, idx, overtypingCapturer)),
                 ( new CommentBasedVariableResolver(model, selection, languageConfigurationService)),
@@ -380,7 +380,7 @@ let SnippetSession = SnippetSession_1 = class SnippetSession {
                 () => clipboardText,
                 0,
                 editor.getSelections().length,
-                editor.getOption(78 ) === 'spread'
+                editor.getOption(79 ) === 'spread'
             )),
             ( new SelectionBasedVariableResolver(model, editor.getSelection(), 0, overtypingCapturer)),
             ( new CommentBasedVariableResolver(model, editor.getSelection(), languageConfigurationService)),

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollActions.js

@@ -1,5 +1,5 @@
 import { EditorAction2 } from '../../../browser/editorExtensions.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
 import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
 import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
@@ -11,7 +11,7 @@ class ToggleStickyScroll extends Action2 {
         super({
             id: 'editor.action.toggleStickyScroll',
             title: {
-                value: ( localizeWithPath(
+                ...( localize2WithPath(
                     'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
                     'toggleEditorStickyScroll',
                     "Toggle Editor Sticky Scroll"
@@ -21,7 +21,6 @@ class ToggleStickyScroll extends Action2 {
                     { key: 'mitoggleStickyScroll', comment: ['&& denotes a mnemonic'] },
                     "&&Toggle Editor Sticky Scroll"
                 )),
-                original: 'Toggle Editor Sticky Scroll',
             },
             category: Categories.View,
             toggled: {
@@ -56,7 +55,7 @@ class FocusStickyScroll extends EditorAction2 {
         super({
             id: 'editor.action.focusStickyScroll',
             title: {
-                value: ( localizeWithPath(
+                ...( localize2WithPath(
                     'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
                     'focusStickyScroll',
                     "Focus Sticky Scroll"
@@ -66,7 +65,6 @@ class FocusStickyScroll extends EditorAction2 {
                     { key: 'mifocusStickyScroll', comment: ['&& denotes a mnemonic'] },
                     "&&Focus Sticky Scroll"
                 )),
-                original: 'Focus Sticky Scroll',
             },
             precondition: ( ContextKeyExpr.and(( ContextKeyExpr.has('config.editor.stickyScroll.enabled')), EditorContextKeys.stickyScrollVisible)),
             menu: [
@@ -82,14 +80,11 @@ class SelectNextStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectNextStickyScrollLine',
-            title: {
-                value: ( localizeWithPath(
-                    'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
-                    'selectNextStickyScrollLine.title',
-                    "Select next sticky scroll line"
-                )),
-                original: 'Select next sticky scroll line'
-            },
+            title: ( localize2WithPath(
+                'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
+                'selectNextStickyScrollLine.title',
+                "Select next sticky scroll line"
+            )),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -105,14 +100,11 @@ class SelectPreviousStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectPreviousStickyScrollLine',
-            title: {
-                value: ( localizeWithPath(
-                    'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
-                    'selectPreviousStickyScrollLine.title',
-                    "Select previous sticky scroll line"
-                )),
-                original: 'Select previous sticky scroll line'
-            },
+            title: ( localize2WithPath(
+                'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
+                'selectPreviousStickyScrollLine.title',
+                "Select previous sticky scroll line"
+            )),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -128,14 +120,11 @@ class GoToStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.goToFocusedStickyScrollLine',
-            title: {
-                value: ( localizeWithPath(
-                    'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
-                    'goToFocusedStickyScrollLine.title',
-                    "Go to focused sticky scroll line"
-                )),
-                original: 'Go to focused sticky scroll line'
-            },
+            title: ( localize2WithPath(
+                'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
+                'goToFocusedStickyScrollLine.title',
+                "Go to focused sticky scroll line"
+            )),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -151,14 +140,11 @@ class SelectEditor extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectEditor',
-            title: {
-                value: ( localizeWithPath(
-                    'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
-                    'selectEditor.title',
-                    "Select Editor"
-                )),
-                original: 'Select Editor'
-            },
+            title: ( localize2WithPath(
+                'vs/editor/contrib/stickyScroll/browser/stickyScrollActions',
+                'selectEditor.title',
+                "Select Editor"
+            )),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,