@codingame/monaco-vscode-api 2.2.2 → 3.1.0

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

@@ -0,0 +1,279 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/keybindings.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { OS } from '../../../../base/common/platform.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { KeybindingLabel } from '../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { Widget } from '../../../../base/browser/ui/widget.js';
+import { append, $, clearNode, Dimension, addDisposableListener, EventType } from '../../../../base/browser/dom.js';
+import { alert } from '../../../../base/browser/ui/aria/aria.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { asCssVariable, editorWidgetBackground, editorWidgetForeground, widgetShadow } from '../../../../platform/theme/common/colorRegistry.js';
+import { SearchWidget } from './preferencesWidgets.js';
+import { Promises, timeout } from '../../../../base/common/async.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { defaultInputBoxStyles, defaultKeybindingLabelStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+var DefineKeybindingWidget_1, DefineKeybindingOverlayWidget_1;
+let KeybindingsSearchWidget = class KeybindingsSearchWidget extends SearchWidget {
+    constructor(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService) {
+        super(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService);
+        this.recordDisposables = this._register(( new DisposableStore()));
+        this._onKeybinding = this._register(( new Emitter()));
+        this.onKeybinding = this._onKeybinding.event;
+        this._onEnter = this._register(( new Emitter()));
+        this.onEnter = this._onEnter.event;
+        this._onEscape = this._register(( new Emitter()));
+        this.onEscape = this._onEscape.event;
+        this._onBlur = this._register(( new Emitter()));
+        this.onBlur = this._onBlur.event;
+        this._register(toDisposable(() => this.stopRecordingKeys()));
+        this._chords = null;
+        this._inputValue = '';
+    }
+    clear() {
+        this._chords = null;
+        super.clear();
+    }
+    startRecordingKeys() {
+        this.recordDisposables.add(addDisposableListener(this.inputBox.inputElement, EventType.KEY_DOWN, (e) => this._onKeyDown(( new StandardKeyboardEvent(e)))));
+        this.recordDisposables.add(addDisposableListener(this.inputBox.inputElement, EventType.BLUR, () => this._onBlur.fire()));
+        this.recordDisposables.add(addDisposableListener(this.inputBox.inputElement, EventType.INPUT, () => {
+            this.setInputValue(this._inputValue);
+        }));
+    }
+    stopRecordingKeys() {
+        this._chords = null;
+        this.recordDisposables.clear();
+    }
+    setInputValue(value) {
+        this._inputValue = value;
+        this.inputBox.value = this._inputValue;
+    }
+    _onKeyDown(keyboardEvent) {
+        keyboardEvent.preventDefault();
+        keyboardEvent.stopPropagation();
+        const options = this.options;
+        if (!options.recordEnter && keyboardEvent.equals(3 )) {
+            this._onEnter.fire();
+            return;
+        }
+        if (keyboardEvent.equals(9 )) {
+            this._onEscape.fire();
+            return;
+        }
+        this.printKeybinding(keyboardEvent);
+    }
+    printKeybinding(keyboardEvent) {
+        const keybinding = this.keybindingService.resolveKeyboardEvent(keyboardEvent);
+        const info = `code: ${keyboardEvent.browserEvent.code}, keyCode: ${keyboardEvent.browserEvent.keyCode}, key: ${keyboardEvent.browserEvent.key} => UI: ${keybinding.getAriaLabel()}, user settings: ${keybinding.getUserSettingsLabel()}, dispatch: ${keybinding.getDispatchChords()[0]}`;
+        const options = this.options;
+        if (!this._chords) {
+            this._chords = [];
+        }
+        const hasIncompleteChord = this._chords.length > 0 && this._chords[this._chords.length - 1].getDispatchChords()[0] === null;
+        if (hasIncompleteChord) {
+            this._chords[this._chords.length - 1] = keybinding;
+        }
+        else {
+            if (this._chords.length === 2) {
+                this._chords = [];
+            }
+            this._chords.push(keybinding);
+        }
+        const value = ( this._chords.map((keybinding) => keybinding.getUserSettingsLabel() || '')).join(' ');
+        this.setInputValue(options.quoteRecordedKeys ? `"${value}"` : value);
+        this.inputBox.inputElement.title = info;
+        this._onKeybinding.fire(this._chords);
+    }
+};
+KeybindingsSearchWidget = ( __decorate([
+    ( __param(2, IContextViewService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IKeybindingService))
+], KeybindingsSearchWidget));
+let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
+    static { DefineKeybindingWidget_1 = this; }
+    static { this.WIDTH = 400; }
+    static { this.HEIGHT = 110; }
+    constructor(parent, instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this._chords = null;
+        this._isVisible = false;
+        this._onHide = this._register(( new Emitter()));
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onShowExistingKeybindings = this._register(( new Emitter()));
+        this.onShowExistingKeybidings = this._onShowExistingKeybindings.event;
+        this._domNode = createFastDomNode(document.createElement('div'));
+        this._domNode.setDisplay('none');
+        this._domNode.setClassName('defineKeybindingWidget');
+        this._domNode.setWidth(DefineKeybindingWidget_1.WIDTH);
+        this._domNode.setHeight(DefineKeybindingWidget_1.HEIGHT);
+        const message = ( localizeWithPath(
+            'vs/workbench/contrib/preferences/browser/keybindingWidgets',
+            'defineKeybinding.initial',
+            "Press desired key combination and then press ENTER."
+        ));
+        append(this._domNode.domNode, $('.message', undefined, message));
+        this._domNode.domNode.style.backgroundColor = asCssVariable(editorWidgetBackground);
+        this._domNode.domNode.style.color = asCssVariable(editorWidgetForeground);
+        this._domNode.domNode.style.boxShadow = `0 2px 8px ${asCssVariable(widgetShadow)}`;
+        this._keybindingInputWidget = this._register(this.instantiationService.createInstance(KeybindingsSearchWidget, this._domNode.domNode, { ariaLabel: message, history: [], inputBoxStyles: defaultInputBoxStyles }));
+        this._keybindingInputWidget.startRecordingKeys();
+        this._register(this._keybindingInputWidget.onKeybinding(keybinding => this.onKeybinding(keybinding)));
+        this._register(this._keybindingInputWidget.onEnter(() => this.hide()));
+        this._register(this._keybindingInputWidget.onEscape(() => this.clearOrHide()));
+        this._register(this._keybindingInputWidget.onBlur(() => this.onCancel()));
+        this._outputNode = append(this._domNode.domNode, $('.output'));
+        this._showExistingKeybindingsNode = append(this._domNode.domNode, $('.existing'));
+        if (parent) {
+            append(parent, this._domNode.domNode);
+        }
+    }
+    get domNode() {
+        return this._domNode.domNode;
+    }
+    define() {
+        this._keybindingInputWidget.clear();
+        return Promises.withAsyncBody(async (c) => {
+            if (!this._isVisible) {
+                this._isVisible = true;
+                this._domNode.setDisplay('block');
+                this._chords = null;
+                this._keybindingInputWidget.setInputValue('');
+                clearNode(this._outputNode);
+                clearNode(this._showExistingKeybindingsNode);
+                await timeout(0);
+                this._keybindingInputWidget.focus();
+            }
+            const disposable = this._onHide.event(() => {
+                c(this.getUserSettingsLabel());
+                disposable.dispose();
+            });
+        });
+    }
+    layout(layout) {
+        const top = Math.round((layout.height - DefineKeybindingWidget_1.HEIGHT) / 2);
+        this._domNode.setTop(top);
+        const left = Math.round((layout.width - DefineKeybindingWidget_1.WIDTH) / 2);
+        this._domNode.setLeft(left);
+    }
+    printExisting(numberOfExisting) {
+        if (numberOfExisting > 0) {
+            const existingElement = $('span.existingText');
+            const text = numberOfExisting === 1 ? ( localizeWithPath(
+                'vs/workbench/contrib/preferences/browser/keybindingWidgets',
+                'defineKeybinding.oneExists',
+                "1 existing command has this keybinding",
+                numberOfExisting
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/preferences/browser/keybindingWidgets',
+                'defineKeybinding.existing',
+                "{0} existing commands have this keybinding",
+                numberOfExisting
+            ));
+            append(existingElement, document.createTextNode(text));
+            alert(text);
+            this._showExistingKeybindingsNode.appendChild(existingElement);
+            existingElement.onmousedown = (e) => { e.preventDefault(); };
+            existingElement.onmouseup = (e) => { e.preventDefault(); };
+            existingElement.onclick = () => { this._onShowExistingKeybindings.fire(this.getUserSettingsLabel()); };
+        }
+    }
+    onKeybinding(keybinding) {
+        this._chords = keybinding;
+        clearNode(this._outputNode);
+        clearNode(this._showExistingKeybindingsNode);
+        const firstLabel = ( new KeybindingLabel(this._outputNode, OS, defaultKeybindingLabelStyles));
+        firstLabel.set(this._chords?.[0] ?? undefined);
+        if (this._chords) {
+            for (let i = 1; i < this._chords.length; i++) {
+                this._outputNode.appendChild(document.createTextNode(( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keybindingWidgets',
+                    'defineKeybinding.chordsTo',
+                    "chord to"
+                ))));
+                const chordLabel = ( new KeybindingLabel(this._outputNode, OS, defaultKeybindingLabelStyles));
+                chordLabel.set(this._chords[i]);
+            }
+        }
+        const label = this.getUserSettingsLabel();
+        if (label) {
+            this._onDidChange.fire(label);
+        }
+    }
+    getUserSettingsLabel() {
+        let label = null;
+        if (this._chords) {
+            label = ( this._chords.map(keybinding => keybinding.getUserSettingsLabel())).join(' ');
+        }
+        return label;
+    }
+    onCancel() {
+        this._chords = null;
+        this.hide();
+    }
+    clearOrHide() {
+        if (this._chords === null) {
+            this.hide();
+        }
+        else {
+            this._chords = null;
+            this._keybindingInputWidget.clear();
+            clearNode(this._outputNode);
+            clearNode(this._showExistingKeybindingsNode);
+        }
+    }
+    hide() {
+        this._domNode.setDisplay('none');
+        this._isVisible = false;
+        this._onHide.fire();
+    }
+};
+DefineKeybindingWidget = DefineKeybindingWidget_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], DefineKeybindingWidget));
+let DefineKeybindingOverlayWidget = class DefineKeybindingOverlayWidget extends Disposable {
+    static { DefineKeybindingOverlayWidget_1 = this; }
+    static { this.ID = 'editor.contrib.defineKeybindingWidget'; }
+    constructor(_editor, instantiationService) {
+        super();
+        this._editor = _editor;
+        this._widget = this._register(instantiationService.createInstance(DefineKeybindingWidget, null));
+        this._editor.addOverlayWidget(this);
+    }
+    getId() {
+        return DefineKeybindingOverlayWidget_1.ID;
+    }
+    getDomNode() {
+        return this._widget.domNode;
+    }
+    getPosition() {
+        return {
+            preference: null
+        };
+    }
+    dispose() {
+        this._editor.removeOverlayWidget(this);
+        super.dispose();
+    }
+    start() {
+        if (this._editor.hasModel()) {
+            this._editor.revealPositionInCenterIfOutsideViewport(this._editor.getPosition(), 0 );
+        }
+        const layoutInfo = this._editor.getLayoutInfo();
+        this._widget.layout(new Dimension(layoutInfo.width, layoutInfo.height));
+        return this._widget.define();
+    }
+};
+DefineKeybindingOverlayWidget = DefineKeybindingOverlayWidget_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], DefineKeybindingOverlayWidget));
+export { DefineKeybindingOverlayWidget, DefineKeybindingWidget, KeybindingsSearchWidget };

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

@@ -1,10 +1,9 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
 import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
 import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { parseKeyboardLayoutDescription, IKeyboardLayoutService, areKeyboardLayoutsEqual, getKeyboardLayoutId } from '../../../../platform/keyboardLayout/common/keyboardLayout.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { Extensions } from '../../../common/contributions.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
 import { KEYBOARD_LAYOUT_OPEN_PICKER } from '../common/preferences.js';
 import { isMacintosh, isWindows } from '../../../../base/common/platform.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
@@ -15,6 +14,7 @@ import { IFileService } from '../../../../platform/files/common/files.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { VSBuffer } from '../../../../base/common/buffer.js';
 let KeyboardLayoutPickerContribution = class KeyboardLayoutPickerContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.keyboardLayoutPicker'; }
     constructor(keyboardLayoutService, statusbarService) {
         super();
         this.keyboardLayoutService = keyboardLayoutService;
@@ -79,8 +79,7 @@ KeyboardLayoutPickerContribution = ( __decorate([
     ( __param(0, IKeyboardLayoutService)),
     ( __param(1, IStatusbarService))
 ], KeyboardLayoutPickerContribution));
-const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
-workbenchContributionsRegistry.registerWorkbenchContribution(KeyboardLayoutPickerContribution, 1 );
+registerWorkbenchContribution2(KeyboardLayoutPickerContribution.ID, KeyboardLayoutPickerContribution, 1 );
 const DEFAULT_CONTENT = [
     `// ${( localizeWithPath(
         'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
@@ -100,11 +99,11 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: KEYBOARD_LAYOUT_OPEN_PICKER,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
                 'keyboard.chooseLayout',
                 "Change Keyboard Layout"
-            )), original: 'Change Keyboard Layout' },
+            )),
             f1: true
         });
     }

package/vscode/src/vs/workbench/contrib/preferences/browser/media/keybindings.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".defineKeybindingWidget{padding:10px;position:absolute}.defineKeybindingWidget .message{text-align:center;width:400px}.defineKeybindingWidget .existing,.defineKeybindingWidget .monaco-inputbox,.defineKeybindingWidget .output{display:block;margin-top:10px;text-align:center;width:400px}.defineKeybindingWidget .input{text-align:center}.defineKeybindingWidget .output{display:flex;justify-content:center}.defineKeybindingWidget .existing .existingText{cursor:pointer;text-decoration:underline}.defineKeybindingWidget .output .monaco-keybinding{margin:0 4px}.monaco-editor .keybindingInfo{background-color:rgba(100,100,250,.2);box-shadow:inset 0 0 0 1px #b9b9b9}.monaco-editor .keybindingError{background-color:hsla(0,94%,69%,.2);box-shadow:inset 0 0 0 1px #b9b9b9}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,64 @@
+import { Codicon } from '../../../../base/common/codicons.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+const settingsScopeDropDownIcon = registerIcon('settings-folder-dropdown', Codicon.triangleDown, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'settingsScopeDropDownIcon',
+ 'Icon for the folder dropdown button in the split JSON Settings editor.'
+)));
+const settingsMoreActionIcon = registerIcon('settings-more-action', Codicon.gear, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'settingsMoreActionIcon',
+ 'Icon for the \'more actions\' action in the Settings UI.'
+)));
+const keybindingsRecordKeysIcon = registerIcon('keybindings-record-keys', Codicon.recordKeys, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'keybindingsRecordKeysIcon',
+ 'Icon for the \'record keys\' action in the keybinding UI.'
+)));
+const keybindingsSortIcon = registerIcon('keybindings-sort', Codicon.sortPrecedence, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'keybindingsSortIcon',
+ 'Icon for the \'sort by precedence\' toggle in the keybinding UI.'
+)));
+const keybindingsEditIcon = registerIcon('keybindings-edit', Codicon.edit, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'keybindingsEditIcon',
+ 'Icon for the edit action in the keybinding UI.'
+)));
+const keybindingsAddIcon = registerIcon('keybindings-add', Codicon.add, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'keybindingsAddIcon',
+ 'Icon for the add action in the keybinding UI.'
+)));
+const settingsEditIcon = registerIcon('settings-edit', Codicon.edit, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'settingsEditIcon',
+ 'Icon for the edit action in the Settings UI.'
+)));
+const settingsRemoveIcon = registerIcon('settings-remove', Codicon.close, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'settingsRemoveIcon',
+ 'Icon for the remove action in the Settings UI.'
+)));
+const settingsDiscardIcon = registerIcon('settings-discard', Codicon.discard, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'preferencesDiscardIcon',
+ 'Icon for the discard action in the Settings UI.'
+)));
+const preferencesClearInputIcon = registerIcon('preferences-clear-input', Codicon.clearAll, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'preferencesClearInput',
+ 'Icon for clear input in the Settings and keybinding UI.'
+)));
+const preferencesFilterIcon = registerIcon('preferences-filter', Codicon.filter, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'settingsFilter',
+ 'Icon for the button that suggests filters for the Settings UI.'
+)));
+const preferencesOpenSettingsIcon = registerIcon('preferences-open-settings', Codicon.goToFile, ( localizeWithPath(
+ 'vs/workbench/contrib/preferences/browser/preferencesIcons',
+ 'preferencesOpenSettings',
+ 'Icon for open settings commands.'
+)));
+export { keybindingsAddIcon, keybindingsEditIcon, keybindingsRecordKeysIcon, keybindingsSortIcon, preferencesClearInputIcon, preferencesFilterIcon, preferencesOpenSettingsIcon, settingsDiscardIcon, settingsEditIcon, settingsMoreActionIcon, settingsRemoveIcon, settingsScopeDropDownIcon };