@codingame/monaco-vscode-a3eaa464-944c-5b8f-8886-213068ba4897-common 16.1.0-shadow-root.1

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@codingame/monaco-vscode-a3eaa464-944c-5b8f-8886-213068ba4897-common",
+  "version": "16.1.0-shadow-root.1",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (keybindings, preferences)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "16.1.0-shadow-root.1"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/workbench/contrib/preferences/browser/keybindingWidgets.d.ts

@@ -0,0 +1,73 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Widget } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/widget";
+import { ResolvedKeybinding } from "@codingame/monaco-vscode-api/vscode/vs/base/common/keybindings";
+import * as dom from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IContextViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { SearchWidget, SearchOptions } from "./preferencesWidgets.js";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+export interface KeybindingsSearchOptions extends SearchOptions {
+    recordEnter?: boolean;
+    quoteRecordedKeys?: boolean;
+}
+export declare class KeybindingsSearchWidget extends SearchWidget {
+    private _chords;
+    private _inputValue;
+    private readonly recordDisposables;
+    private _onKeybinding;
+    readonly onKeybinding: Event<ResolvedKeybinding[] | null>;
+    private _onEnter;
+    readonly onEnter: Event<void>;
+    private _onEscape;
+    readonly onEscape: Event<void>;
+    private _onBlur;
+    readonly onBlur: Event<void>;
+    constructor(parent: HTMLElement, options: KeybindingsSearchOptions, contextViewService: IContextViewService, instantiationService: IInstantiationService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService);
+    clear(): void;
+    startRecordingKeys(): void;
+    stopRecordingKeys(): void;
+    setInputValue(value: string): void;
+    private _onKeyDown;
+    private printKeybinding;
+}
+export declare class DefineKeybindingWidget extends Widget {
+    private readonly instantiationService;
+    private static readonly WIDTH;
+    private static readonly HEIGHT;
+    private _domNode;
+    private _keybindingInputWidget;
+    private _outputNode;
+    private _showExistingKeybindingsNode;
+    private readonly _keybindingDisposables;
+    private _chords;
+    private _isVisible;
+    private _onHide;
+    private _onDidChange;
+    onDidChange: Event<string>;
+    private _onShowExistingKeybindings;
+    readonly onShowExistingKeybidings: Event<string | null>;
+    constructor(parent: HTMLElement | null, instantiationService: IInstantiationService);
+    get domNode(): HTMLElement;
+    define(): Promise<string | null>;
+    layout(layout: dom.Dimension): void;
+    printExisting(numberOfExisting: number): void;
+    private onKeybinding;
+    private getUserSettingsLabel;
+    private onCancel;
+    private clearOrHide;
+    private hide;
+}
+export declare class DefineKeybindingOverlayWidget extends Disposable implements IOverlayWidget {
+    private _editor;
+    private static readonly ID;
+    private readonly _widget;
+    constructor(_editor: ICodeEditor, instantiationService: IInstantiationService);
+    getId(): string;
+    getDomNode(): HTMLElement;
+    getPosition(): IOverlayWidgetPosition;
+    dispose(): void;
+    start(): Promise<string | null>;
+}

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

@@ -0,0 +1,280 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as keybindings from './media/keybindings.css';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { DisposableStore, toDisposable, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeybindingLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
+import { Widget } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/widget';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { addDisposableListener, EventType, append, $, clearNode, Dimension } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { createFastDomNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/fastDomNode';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IContextViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorWidgetBackground, editorWidgetForeground, widgetShadow } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { ScrollType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon';
+import { SearchWidget } from './preferencesWidgets.js';
+import { Promises, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { defaultInputBoxStyles, defaultKeybindingLabelStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+
+var DefineKeybindingWidget_1, DefineKeybindingOverlayWidget_1;
+registerCss(keybindings);
+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(KeyCode.Enter)) {
+            this._onEnter.fire();
+            return;
+        }
+        if (keyboardEvent.equals(KeyCode.Escape)) {
+            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._keybindingDisposables = this._register(( new DisposableStore()));
+        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 = ( localize(8436, "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: ( new Set([])), 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 ? ( localize(8437, "1 existing command has this keybinding", numberOfExisting)) : ( localize(8438, "{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._keybindingDisposables.clear();
+        this._chords = keybinding;
+        clearNode(this._outputNode);
+        clearNode(this._showExistingKeybindingsNode);
+        const firstLabel = this._keybindingDisposables.add(( 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(( localize(8439, "chord to"))));
+                const chordLabel = this._keybindingDisposables.add(( 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(), ScrollType.Smooth);
+        }
+        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/media/keybindings.css

@@ -0,0 +1,38 @@
+.defineKeybindingWidget {
+	padding: 10px;
+	position: absolute;
+}
+.defineKeybindingWidget .message {
+	width: 400px;
+	text-align: center;
+}
+.defineKeybindingWidget .monaco-inputbox,
+.defineKeybindingWidget .output,
+.defineKeybindingWidget .existing {
+	margin-top:10px;
+	width: 400px;
+	display: block;
+	text-align: center;
+}
+.defineKeybindingWidget .input {
+	text-align: center;
+}
+.defineKeybindingWidget .output {
+	display: flex;
+	justify-content: center;
+}
+.defineKeybindingWidget .existing .existingText {
+	text-decoration: underline;
+	cursor: pointer;
+}
+.defineKeybindingWidget .output .monaco-keybinding {
+	margin: 0px 4px;
+}
+.monaco-editor .keybindingInfo {
+	box-shadow:	inset 0 0 0 1px #B9B9B9;
+	background-color: rgba(100, 100, 250, 0.2);
+}
+.monaco-editor .keybindingError {
+	box-shadow:	inset 0 0 0 1px #B9B9B9;
+	background-color: rgba(250, 100, 100, 0.2);
+}

package/vscode/src/vs/workbench/contrib/preferences/browser/preferencesIcons.d.ts

@@ -0,0 +1,12 @@
+export declare const settingsScopeDropDownIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const settingsMoreActionIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const keybindingsRecordKeysIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const keybindingsSortIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const keybindingsEditIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const keybindingsAddIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const settingsEditIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const settingsRemoveIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const settingsDiscardIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const preferencesClearInputIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const preferencesFilterIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+export declare const preferencesOpenSettingsIcon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;

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

@@ -0,0 +1,22 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+
+const settingsScopeDropDownIcon = registerIcon('settings-folder-dropdown', Codicon.triangleDown, ( localize(
+ 8530,
+ 'Icon for the folder dropdown button in the split JSON Settings editor.'
+)));
+const settingsMoreActionIcon = registerIcon('settings-more-action', Codicon.gear, ( localize(8531, 'Icon for the \'more actions\' action in the Settings UI.')));
+const keybindingsRecordKeysIcon = registerIcon('keybindings-record-keys', Codicon.recordKeys, ( localize(8532, 'Icon for the \'record keys\' action in the keybinding UI.')));
+const keybindingsSortIcon = registerIcon('keybindings-sort', Codicon.sortPrecedence, ( localize(8533, 'Icon for the \'sort by precedence\' toggle in the keybinding UI.')));
+const keybindingsEditIcon = registerIcon('keybindings-edit', Codicon.edit, ( localize(8534, 'Icon for the edit action in the keybinding UI.')));
+const keybindingsAddIcon = registerIcon('keybindings-add', Codicon.add, ( localize(8535, 'Icon for the add action in the keybinding UI.')));
+const settingsEditIcon = registerIcon('settings-edit', Codicon.edit, ( localize(8536, 'Icon for the edit action in the Settings UI.')));
+const settingsRemoveIcon = registerIcon('settings-remove', Codicon.close, ( localize(8537, 'Icon for the remove action in the Settings UI.')));
+const settingsDiscardIcon = registerIcon('settings-discard', Codicon.discard, ( localize(8538, 'Icon for the discard action in the Settings UI.')));
+const preferencesClearInputIcon = registerIcon('preferences-clear-input', Codicon.clearAll, ( localize(8539, 'Icon for clear input in the Settings and keybinding UI.')));
+const preferencesFilterIcon = registerIcon('preferences-filter', Codicon.filter, ( localize(8540, 'Icon for the button that suggests filters for the Settings UI.')));
+const preferencesOpenSettingsIcon = registerIcon('preferences-open-settings', Codicon.goToFile, ( localize(8541, 'Icon for open settings commands.')));
+
+export { keybindingsAddIcon, keybindingsEditIcon, keybindingsRecordKeysIcon, keybindingsSortIcon, preferencesClearInputIcon, preferencesFilterIcon, preferencesOpenSettingsIcon, settingsDiscardIcon, settingsEditIcon, settingsMoreActionIcon, settingsRemoveIcon, settingsScopeDropDownIcon };

package/vscode/src/vs/workbench/contrib/preferences/browser/preferencesWidgets.d.ts

@@ -0,0 +1,130 @@
+import * as DOM from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { BaseActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { HistoryInputBox, IHistoryInputOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox";
+import { Widget } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/widget";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICodeEditor, IEditorMouseEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import { IContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IContextViewService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IWorkspaceFolder } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+export declare class FolderSettingsActionViewItem extends BaseActionViewItem {
+    private readonly contextService;
+    private readonly contextMenuService;
+    private readonly hoverService;
+    private _folder;
+    private _folderSettingCounts;
+    private container;
+    private anchorElement;
+    private anchorElementHover;
+    private labelElement;
+    private detailsElement;
+    private dropDownElement;
+    constructor(action: IAction, contextService: IWorkspaceContextService, contextMenuService: IContextMenuService, hoverService: IHoverService);
+    get folder(): IWorkspaceFolder | null;
+    set folder(folder: IWorkspaceFolder | null);
+    setCount(settingsTarget: URI, count: number): void;
+    render(container: HTMLElement): void;
+    private onKeyUp;
+    onClick(event: DOM.EventLike): void;
+    protected updateEnabled(): void;
+    protected updateChecked(): void;
+    private onWorkspaceFoldersChanged;
+    private update;
+    private showMenu;
+    private getDropdownMenuActions;
+    private labelWithCount;
+}
+export type SettingsTarget = ConfigurationTarget.APPLICATION | ConfigurationTarget.USER_LOCAL | ConfigurationTarget.USER_REMOTE | ConfigurationTarget.WORKSPACE | URI;
+export interface ISettingsTargetsWidgetOptions {
+    enableRemoteSettings?: boolean;
+}
+export declare class SettingsTargetsWidget extends Widget {
+    private readonly contextService;
+    private readonly instantiationService;
+    private readonly environmentService;
+    private readonly labelService;
+    private readonly languageService;
+    private settingsSwitcherBar;
+    private userLocalSettings;
+    private userRemoteSettings;
+    private workspaceSettings;
+    private folderSettingsAction;
+    private folderSettings;
+    private options;
+    private _settingsTarget;
+    private readonly _onDidTargetChange;
+    readonly onDidTargetChange: Event<SettingsTarget>;
+    constructor(parent: HTMLElement, options: ISettingsTargetsWidgetOptions | undefined, contextService: IWorkspaceContextService, instantiationService: IInstantiationService, environmentService: IWorkbenchEnvironmentService, labelService: ILabelService, languageService: ILanguageService);
+    private resetLabels;
+    private create;
+    get settingsTarget(): SettingsTarget | null;
+    set settingsTarget(settingsTarget: SettingsTarget | null);
+    setResultCount(settingsTarget: SettingsTarget, count: number): void;
+    updateLanguageFilterIndicators(filter: string | undefined): void;
+    private onWorkbenchStateChanged;
+    updateTarget(settingsTarget: SettingsTarget): Promise<void>;
+    private update;
+}
+export interface SearchOptions extends IHistoryInputOptions {
+    focusKey?: IContextKey<boolean>;
+    showResultCount?: boolean;
+    ariaLive?: string;
+    ariaLabelledBy?: string;
+}
+export declare class SearchWidget extends Widget {
+    protected options: SearchOptions;
+    private readonly contextViewService;
+    protected instantiationService: IInstantiationService;
+    private readonly contextKeyService;
+    protected readonly keybindingService: IKeybindingService;
+    domNode: HTMLElement;
+    private countElement;
+    private searchContainer;
+    inputBox: HistoryInputBox;
+    private controlsDiv;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<string>;
+    private readonly _onFocus;
+    readonly onFocus: Event<void>;
+    constructor(parent: HTMLElement, options: SearchOptions, contextViewService: IContextViewService, instantiationService: IInstantiationService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService);
+    private create;
+    private createSearchContainer;
+    protected createInputBox(parent: HTMLElement): HistoryInputBox;
+    showMessage(message: string): void;
+    layout(dimension: DOM.Dimension): void;
+    private getControlsWidth;
+    focus(): void;
+    hasFocus(): boolean;
+    clear(): void;
+    getValue(): string;
+    setValue(value: string): string;
+    dispose(): void;
+}
+export declare class EditPreferenceWidget<T> extends Disposable {
+    private editor;
+    private _line;
+    private _preferences;
+    private readonly _editPreferenceDecoration;
+    private readonly _onClick;
+    readonly onClick: Event<IEditorMouseEvent>;
+    constructor(editor: ICodeEditor);
+    get preferences(): T[];
+    getLine(): number;
+    show(line: number, hoverMessage: string, preferences: T[]): void;
+    hide(): void;
+    isVisible(): boolean;
+    dispose(): void;
+}

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

@@ -0,0 +1,492 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, addDisposableListener, EventType, EventHelper, append, trackFocus, getTotalWidth } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { ActionBar, ActionsOrientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Widget } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/widget';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { MouseTargetType } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { TrackedRangeStickiness } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ContextScopedHistoryInputBox } from '@codingame/monaco-vscode-api/vscode/vs/platform/history/browser/contextScopedHistoryWidget';
+import { showHistoryKeybindingHint } from '@codingame/monaco-vscode-api/vscode/vs/platform/history/browser/historyWidgetKeybindingHint';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService, IContextViewService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import { contrastBorder } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import { badgeBackground, badgeForeground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { WorkbenchState, isWorkspaceFolder } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { settingsScopeDropDownIcon, settingsEditIcon } from './preferencesIcons.js';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+
+let FolderSettingsActionViewItem = class FolderSettingsActionViewItem extends BaseActionViewItem {
+    constructor(action, contextService, contextMenuService, hoverService) {
+        super(null, action);
+        this.contextService = contextService;
+        this.contextMenuService = contextMenuService;
+        this.hoverService = hoverService;
+        this._folderSettingCounts = ( new Map());
+        const workspace = this.contextService.getWorkspace();
+        this._folder = workspace.folders.length === 1 ? workspace.folders[0] : null;
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.onWorkspaceFoldersChanged()));
+    }
+    get folder() {
+        return this._folder;
+    }
+    set folder(folder) {
+        this._folder = folder;
+        this.update();
+    }
+    setCount(settingsTarget, count) {
+        const workspaceFolder = this.contextService.getWorkspaceFolder(settingsTarget);
+        if (!workspaceFolder) {
+            throw ( new Error('unknown folder'));
+        }
+        const folder = workspaceFolder.uri;
+        this._folderSettingCounts.set(( folder.toString()), count);
+        this.update();
+    }
+    render(container) {
+        this.element = container;
+        this.container = container;
+        this.labelElement = $('.action-title');
+        this.detailsElement = $('.action-details');
+        this.dropDownElement = $('.dropdown-icon.hide' + ThemeIcon.asCSSSelector(settingsScopeDropDownIcon));
+        this.anchorElement = $('a.action-label.folder-settings', {
+            role: 'button',
+            'aria-haspopup': 'true',
+            'tabindex': '0'
+        }, this.labelElement, this.detailsElement, this.dropDownElement);
+        this.anchorElementHover = this._register(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), this.anchorElement, ''));
+        this._register(addDisposableListener(this.anchorElement, EventType.MOUSE_DOWN, e => EventHelper.stop(e)));
+        this._register(addDisposableListener(this.anchorElement, EventType.CLICK, e => this.onClick(e)));
+        this._register(addDisposableListener(this.container, EventType.KEY_UP, e => this.onKeyUp(e)));
+        append(this.container, this.anchorElement);
+        this.update();
+    }
+    onKeyUp(event) {
+        const keyboardEvent = ( new StandardKeyboardEvent(event));
+        switch (keyboardEvent.keyCode) {
+            case KeyCode.Enter:
+            case KeyCode.Space:
+                this.onClick(event);
+                return;
+        }
+    }
+    onClick(event) {
+        EventHelper.stop(event, true);
+        if (!this.folder || this._action.checked) {
+            this.showMenu();
+        }
+        else {
+            this._action.run(this._folder);
+        }
+    }
+    updateEnabled() {
+        this.update();
+    }
+    updateChecked() {
+        this.update();
+    }
+    onWorkspaceFoldersChanged() {
+        const oldFolder = this._folder;
+        const workspace = this.contextService.getWorkspace();
+        if (oldFolder) {
+            this._folder = workspace.folders.filter(folder => isEqual(folder.uri, oldFolder.uri))[0] || workspace.folders[0];
+        }
+        this._folder = this._folder ? this._folder : workspace.folders.length === 1 ? workspace.folders[0] : null;
+        this.update();
+        if (this._action.checked) {
+            this._action.run(this._folder);
+        }
+    }
+    update() {
+        let total = 0;
+        this._folderSettingCounts.forEach(n => total += n);
+        const workspace = this.contextService.getWorkspace();
+        if (this._folder) {
+            this.labelElement.textContent = this._folder.name;
+            this.anchorElementHover.update(this._folder.name);
+            const detailsText = this.labelWithCount(this._action.label, total);
+            this.detailsElement.textContent = detailsText;
+            this.dropDownElement.classList.toggle('hide', workspace.folders.length === 1 || !this._action.checked);
+        }
+        else {
+            const labelText = this.labelWithCount(this._action.label, total);
+            this.labelElement.textContent = labelText;
+            this.detailsElement.textContent = '';
+            this.anchorElementHover.update(this._action.label);
+            this.dropDownElement.classList.remove('hide');
+        }
+        this.anchorElement.classList.toggle('checked', this._action.checked);
+        this.container.classList.toggle('disabled', !this._action.enabled);
+    }
+    showMenu() {
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => this.container,
+            getActions: () => this.getDropdownMenuActions(),
+            getActionViewItem: () => undefined,
+            onHide: () => {
+                this.anchorElement.blur();
+            }
+        });
+    }
+    getDropdownMenuActions() {
+        const actions = [];
+        const workspaceFolders = this.contextService.getWorkspace().folders;
+        if (this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE && workspaceFolders.length > 0) {
+            actions.push(...( workspaceFolders.map((folder, index) => {
+                const folderCount = this._folderSettingCounts.get(( folder.uri.toString()));
+                return {
+                    id: 'folderSettingsTarget' + index,
+                    label: this.labelWithCount(folder.name, folderCount),
+                    tooltip: this.labelWithCount(folder.name, folderCount),
+                    checked: !!this.folder && isEqual(this.folder.uri, folder.uri),
+                    enabled: true,
+                    class: undefined,
+                    run: () => this._action.run(folder)
+                };
+            })));
+        }
+        return actions;
+    }
+    labelWithCount(label, count) {
+        if (count) {
+            label += ` (${count})`;
+        }
+        return label;
+    }
+};
+FolderSettingsActionViewItem = ( __decorate([
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IHoverService))
+], FolderSettingsActionViewItem));
+let SettingsTargetsWidget = class SettingsTargetsWidget extends Widget {
+    constructor(parent, options, contextService, instantiationService, environmentService, labelService, languageService) {
+        super();
+        this.contextService = contextService;
+        this.instantiationService = instantiationService;
+        this.environmentService = environmentService;
+        this.labelService = labelService;
+        this.languageService = languageService;
+        this._settingsTarget = null;
+        this._onDidTargetChange = this._register(( new Emitter()));
+        this.onDidTargetChange = this._onDidTargetChange.event;
+        this.options = options ?? {};
+        this.create(parent);
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.onWorkbenchStateChanged()));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.update()));
+    }
+    resetLabels() {
+        const remoteAuthority = this.environmentService.remoteAuthority;
+        const hostLabel = remoteAuthority && this.labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority);
+        this.userLocalSettings.label = ( localize(8557, "User"));
+        this.userRemoteSettings.label = ( localize(8558, "Remote")) + (hostLabel ? ` [${hostLabel}]` : '');
+        this.workspaceSettings.label = ( localize(8559, "Workspace"));
+        this.folderSettingsAction.label = ( localize(8560, "Folder"));
+    }
+    create(parent) {
+        const settingsTabsWidget = append(parent, $('.settings-tabs-widget'));
+        this.settingsSwitcherBar = this._register(( new ActionBar(settingsTabsWidget, {
+            orientation: ActionsOrientation.HORIZONTAL,
+            focusOnlyEnabledItems: true,
+            ariaLabel: ( localize(8561, "Settings Switcher")),
+            ariaRole: 'tablist',
+            actionViewItemProvider: (action, options) => action.id === 'folderSettings' ? this.folderSettings : undefined
+        })));
+        this.userLocalSettings = ( new Action(
+            'userSettings',
+            '',
+            '.settings-tab',
+            true,
+            () => this.updateTarget(ConfigurationTarget.USER_LOCAL)
+        ));
+        this.userLocalSettings.tooltip = ( localize(8557, "User"));
+        this.userRemoteSettings = ( new Action(
+            'userSettingsRemote',
+            '',
+            '.settings-tab',
+            true,
+            () => this.updateTarget(ConfigurationTarget.USER_REMOTE)
+        ));
+        const remoteAuthority = this.environmentService.remoteAuthority;
+        const hostLabel = remoteAuthority && this.labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority);
+        this.userRemoteSettings.tooltip = ( localize(8558, "Remote")) + (hostLabel ? ` [${hostLabel}]` : '');
+        this.workspaceSettings = ( new Action(
+            'workspaceSettings',
+            '',
+            '.settings-tab',
+            false,
+            () => this.updateTarget(ConfigurationTarget.WORKSPACE)
+        ));
+        this.folderSettingsAction = ( new Action('folderSettings', '', '.settings-tab', false, async (folder) => {
+            this.updateTarget(isWorkspaceFolder(folder) ? folder.uri : ConfigurationTarget.USER_LOCAL);
+        }));
+        this.folderSettings = this.instantiationService.createInstance(FolderSettingsActionViewItem, this.folderSettingsAction);
+        this.resetLabels();
+        this.update();
+        this.settingsSwitcherBar.push([this.userLocalSettings, this.userRemoteSettings, this.workspaceSettings, this.folderSettingsAction]);
+    }
+    get settingsTarget() {
+        return this._settingsTarget;
+    }
+    set settingsTarget(settingsTarget) {
+        this._settingsTarget = settingsTarget;
+        this.userLocalSettings.checked = ConfigurationTarget.USER_LOCAL === this.settingsTarget;
+        this.userRemoteSettings.checked = ConfigurationTarget.USER_REMOTE === this.settingsTarget;
+        this.workspaceSettings.checked = ConfigurationTarget.WORKSPACE === this.settingsTarget;
+        if (this.settingsTarget instanceof URI) {
+            this.folderSettings.action.checked = true;
+            this.folderSettings.folder = this.contextService.getWorkspaceFolder(this.settingsTarget);
+        }
+        else {
+            this.folderSettings.action.checked = false;
+        }
+    }
+    setResultCount(settingsTarget, count) {
+        if (settingsTarget === ConfigurationTarget.WORKSPACE) {
+            let label = ( localize(8559, "Workspace"));
+            if (count) {
+                label += ` (${count})`;
+            }
+            this.workspaceSettings.label = label;
+        }
+        else if (settingsTarget === ConfigurationTarget.USER_LOCAL) {
+            let label = ( localize(8557, "User"));
+            if (count) {
+                label += ` (${count})`;
+            }
+            this.userLocalSettings.label = label;
+        }
+        else if (settingsTarget instanceof URI) {
+            this.folderSettings.setCount(settingsTarget, count);
+        }
+    }
+    updateLanguageFilterIndicators(filter) {
+        this.resetLabels();
+        if (filter) {
+            const languageToUse = this.languageService.getLanguageName(filter);
+            if (languageToUse) {
+                const languageSuffix = ` [${languageToUse}]`;
+                this.userLocalSettings.label += languageSuffix;
+                this.userRemoteSettings.label += languageSuffix;
+                this.workspaceSettings.label += languageSuffix;
+                this.folderSettingsAction.label += languageSuffix;
+            }
+        }
+    }
+    onWorkbenchStateChanged() {
+        this.folderSettings.folder = null;
+        this.update();
+        if (this.settingsTarget === ConfigurationTarget.WORKSPACE && this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
+            this.updateTarget(ConfigurationTarget.USER_LOCAL);
+        }
+    }
+    updateTarget(settingsTarget) {
+        const isSameTarget = this.settingsTarget === settingsTarget ||
+            settingsTarget instanceof URI &&
+                this.settingsTarget instanceof URI &&
+                isEqual(this.settingsTarget, settingsTarget);
+        if (!isSameTarget) {
+            this.settingsTarget = settingsTarget;
+            this._onDidTargetChange.fire(this.settingsTarget);
+        }
+        return Promise.resolve(undefined);
+    }
+    async update() {
+        this.settingsSwitcherBar.domNode.classList.toggle('empty-workbench', this.contextService.getWorkbenchState() === WorkbenchState.EMPTY);
+        this.userRemoteSettings.enabled = !!(this.options.enableRemoteSettings && this.environmentService.remoteAuthority);
+        this.workspaceSettings.enabled = this.contextService.getWorkbenchState() !== WorkbenchState.EMPTY;
+        this.folderSettings.action.enabled = this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE && this.contextService.getWorkspace().folders.length > 0;
+        this.workspaceSettings.tooltip = ( localize(8559, "Workspace"));
+    }
+};
+SettingsTargetsWidget = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ILanguageService))
+], SettingsTargetsWidget));
+let SearchWidget = class SearchWidget extends Widget {
+    constructor(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService) {
+        super();
+        this.options = options;
+        this.contextViewService = contextViewService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.keybindingService = keybindingService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onFocus = this._register(( new Emitter()));
+        this.onFocus = this._onFocus.event;
+        this.create(parent);
+    }
+    create(parent) {
+        this.domNode = append(parent, $('div.settings-header-widget'));
+        this.createSearchContainer(append(this.domNode, $('div.settings-search-container')));
+        this.controlsDiv = append(this.domNode, $('div.settings-search-controls'));
+        if (this.options.showResultCount) {
+            this.countElement = append(this.controlsDiv, $('.settings-count-widget'));
+            this.countElement.style.backgroundColor = asCssVariable(badgeBackground);
+            this.countElement.style.color = asCssVariable(badgeForeground);
+            this.countElement.style.border = `1px solid ${asCssVariable(contrastBorder)}`;
+        }
+        this.inputBox.inputElement.setAttribute('aria-live', this.options.ariaLive || 'off');
+        if (this.options.ariaLabelledBy) {
+            this.inputBox.inputElement.setAttribute('aria-labelledBy', this.options.ariaLabelledBy);
+        }
+        const focusTracker = this._register(trackFocus(this.inputBox.inputElement));
+        this._register(focusTracker.onDidFocus(() => this._onFocus.fire()));
+        const focusKey = this.options.focusKey;
+        if (focusKey) {
+            this._register(focusTracker.onDidFocus(() => focusKey.set(true)));
+            this._register(focusTracker.onDidBlur(() => focusKey.set(false)));
+        }
+    }
+    createSearchContainer(searchContainer) {
+        this.searchContainer = searchContainer;
+        const searchInput = append(this.searchContainer, $('div.settings-search-input'));
+        this.inputBox = this._register(this.createInputBox(searchInput));
+        this._register(this.inputBox.onDidChange(value => this._onDidChange.fire(value)));
+    }
+    createInputBox(parent) {
+        const showHistoryHint = () => showHistoryKeybindingHint(this.keybindingService);
+        return ( new ContextScopedHistoryInputBox(
+            parent,
+            this.contextViewService,
+            { ...this.options, showHistoryHint },
+            this.contextKeyService
+        ));
+    }
+    showMessage(message) {
+        if (this.countElement && message !== this.countElement.textContent) {
+            this.countElement.textContent = message;
+            this.inputBox.inputElement.setAttribute('aria-label', message);
+            this.inputBox.inputElement.style.paddingRight = this.getControlsWidth() + 'px';
+        }
+    }
+    layout(dimension) {
+        if (dimension.width < 400) {
+            this.countElement?.classList.add('hide');
+            this.inputBox.inputElement.style.paddingRight = '0px';
+        }
+        else {
+            this.countElement?.classList.remove('hide');
+            this.inputBox.inputElement.style.paddingRight = this.getControlsWidth() + 'px';
+        }
+    }
+    getControlsWidth() {
+        const countWidth = this.countElement ? getTotalWidth(this.countElement) : 0;
+        return countWidth + 20;
+    }
+    focus() {
+        this.inputBox.focus();
+        if (this.getValue()) {
+            this.inputBox.select();
+        }
+    }
+    hasFocus() {
+        return this.inputBox.hasFocus();
+    }
+    clear() {
+        this.inputBox.value = '';
+    }
+    getValue() {
+        return this.inputBox.value;
+    }
+    setValue(value) {
+        return this.inputBox.value = value;
+    }
+    dispose() {
+        this.options.focusKey?.set(false);
+        super.dispose();
+    }
+};
+SearchWidget = ( __decorate([
+    ( __param(2, IContextViewService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IKeybindingService))
+], SearchWidget));
+class EditPreferenceWidget extends Disposable {
+    constructor(editor) {
+        super();
+        this.editor = editor;
+        this._line = -1;
+        this._preferences = [];
+        this._onClick = this._register(( new Emitter()));
+        this.onClick = this._onClick.event;
+        this._editPreferenceDecoration = this.editor.createDecorationsCollection();
+        this._register(this.editor.onMouseDown((e) => {
+            if (e.target.type !== MouseTargetType.GUTTER_GLYPH_MARGIN || e.target.detail.isAfterLines || !this.isVisible()) {
+                return;
+            }
+            this._onClick.fire(e);
+        }));
+    }
+    get preferences() {
+        return this._preferences;
+    }
+    getLine() {
+        return this._line;
+    }
+    show(line, hoverMessage, preferences) {
+        this._preferences = preferences;
+        const newDecoration = [];
+        this._line = line;
+        newDecoration.push({
+            options: {
+                description: 'edit-preference-widget-decoration',
+                glyphMarginClassName: ThemeIcon.asClassName(settingsEditIcon),
+                glyphMarginHoverMessage: ( new MarkdownString()).appendText(hoverMessage),
+                stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+            },
+            range: {
+                startLineNumber: line,
+                startColumn: 1,
+                endLineNumber: line,
+                endColumn: 1
+            }
+        });
+        this._editPreferenceDecoration.set(newDecoration);
+    }
+    hide() {
+        this._editPreferenceDecoration.clear();
+    }
+    isVisible() {
+        return this._editPreferenceDecoration.length > 0;
+    }
+    dispose() {
+        this.hide();
+        super.dispose();
+    }
+}
+
+export { EditPreferenceWidget, FolderSettingsActionViewItem, SearchWidget, SettingsTargetsWidget };