@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/preferences/browser/tocTree.js

@@ -0,0 +1,196 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DefaultStyleController } from 'monaco-editor/esm/vs/base/browser/ui/list/listWidget.js';
+import { RenderIndentGuides } from 'monaco-editor/esm/vs/base/browser/ui/tree/abstractTree.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { WorkbenchObjectTree, IListService } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { getListStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { editorBackground, focusBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { SettingsTreeFilter } from './settingsTree.js';
+import { SettingsTreeGroupElement, SettingsTreeSettingElement } from './settingsTreeModels.js';
+import { settingsHeaderForeground, settingsHeaderHoverForeground } from '../common/settingsEditorColorRegistry.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+const $ = dom.$;
+let TOCTreeModel = class TOCTreeModel {
+    constructor(_viewState, environmentService) {
+        this._viewState = _viewState;
+        this.environmentService = environmentService;
+        this._currentSearchModel = null;
+    }
+    get settingsTreeRoot() {
+        return this._settingsTreeRoot;
+    }
+    set settingsTreeRoot(value) {
+        this._settingsTreeRoot = value;
+        this.update();
+    }
+    get currentSearchModel() {
+        return this._currentSearchModel;
+    }
+    set currentSearchModel(model) {
+        this._currentSearchModel = model;
+        this.update();
+    }
+    get children() {
+        return this._settingsTreeRoot.children;
+    }
+    update() {
+        if (this._settingsTreeRoot) {
+            this.updateGroupCount(this._settingsTreeRoot);
+        }
+    }
+    updateGroupCount(group) {
+        group.children.forEach(child => {
+            if (child instanceof SettingsTreeGroupElement) {
+                this.updateGroupCount(child);
+            }
+        });
+        const childCount = group.children
+            .filter(child => child instanceof SettingsTreeGroupElement)
+            .reduce((acc, cur) => acc + cur.count, 0);
+        group.count = childCount + this.getGroupCount(group);
+    }
+    getGroupCount(group) {
+        return group.children.filter(child => {
+            if (!(child instanceof SettingsTreeSettingElement)) {
+                return false;
+            }
+            if (this._currentSearchModel && !this._currentSearchModel.root.containsSetting(child.setting.key)) {
+                return false;
+            }
+            const isRemote = !!this.environmentService.remoteAuthority;
+            return child.matchesScope(this._viewState.settingsTarget, isRemote) &&
+                child.matchesAllTags(this._viewState.tagFilters) &&
+                child.matchesAnyFeature(this._viewState.featureFilters) &&
+                child.matchesAnyExtension(this._viewState.extensionFilters) &&
+                child.matchesAnyId(this._viewState.idFilters);
+        }).length;
+    }
+};
+TOCTreeModel = ( __decorate([
+    ( __param(1, IWorkbenchEnvironmentService))
+], TOCTreeModel));
+const TOC_ENTRY_TEMPLATE_ID = 'settings.toc.entry';
+class TOCRenderer {
+    constructor() {
+        this.templateId = TOC_ENTRY_TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        return {
+            labelElement: dom.append(container, $('.settings-toc-entry')),
+            countElement: dom.append(container, $('.settings-toc-count'))
+        };
+    }
+    renderElement(node, index, template) {
+        const element = node.element;
+        const count = element.count;
+        const label = element.label;
+        template.labelElement.textContent = label;
+        template.labelElement.title = label;
+        if (count) {
+            template.countElement.textContent = ` (${count})`;
+        }
+        else {
+            template.countElement.textContent = '';
+        }
+    }
+    disposeTemplate(templateData) {
+    }
+}
+class TOCTreeDelegate {
+    getTemplateId(element) {
+        return TOC_ENTRY_TEMPLATE_ID;
+    }
+    getHeight(element) {
+        return 22;
+    }
+}
+function createTOCIterator(model, tree) {
+    const groupChildren = model.children.filter(c => c instanceof SettingsTreeGroupElement);
+    return ( Iterable.map(groupChildren, g => {
+        const hasGroupChildren = ( g.children.some(c => c instanceof SettingsTreeGroupElement));
+        return {
+            element: g,
+            collapsed: undefined,
+            collapsible: hasGroupChildren,
+            children: g instanceof SettingsTreeGroupElement ?
+                createTOCIterator(g) :
+                undefined
+        };
+    }));
+}
+class SettingsAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localize({
+            key: 'settingsTOC',
+            comment: ['A label for the table of contents for the full settings list']
+        }, "Settings Table of Contents"));
+    }
+    getAriaLabel(element) {
+        if (!element) {
+            return '';
+        }
+        if (element instanceof SettingsTreeGroupElement) {
+            return ( localize('groupRowAriaLabel', "{0}, group", element.label));
+        }
+        return '';
+    }
+    getAriaLevel(element) {
+        let i = 1;
+        while (element instanceof SettingsTreeGroupElement && element.parent) {
+            i++;
+            element = element.parent;
+        }
+        return i;
+    }
+}
+let TOCTree = class TOCTree extends WorkbenchObjectTree {
+    constructor(container, viewState, contextKeyService, listService, configurationService, instantiationService) {
+        const filter = instantiationService.createInstance(SettingsTreeFilter, viewState);
+        const options = {
+            filter,
+            multipleSelectionSupport: false,
+            identityProvider: {
+                getId(e) {
+                    return e.id;
+                }
+            },
+            styleController: id => ( new DefaultStyleController(dom.createStyleSheet(container), id)),
+            accessibilityProvider: instantiationService.createInstance(SettingsAccessibilityProvider),
+            collapseByDefault: true,
+            horizontalScrolling: false,
+            hideTwistiesOfChildlessElements: true,
+            renderIndentGuides: RenderIndentGuides.None
+        };
+        super('SettingsTOC', container, ( new TOCTreeDelegate()), [( new TOCRenderer())], options, instantiationService, contextKeyService, listService, configurationService);
+        this.style(getListStyles({
+            listBackground: editorBackground,
+            listFocusOutline: focusBorder,
+            listActiveSelectionBackground: editorBackground,
+            listActiveSelectionForeground: settingsHeaderForeground,
+            listFocusAndSelectionBackground: editorBackground,
+            listFocusAndSelectionForeground: settingsHeaderForeground,
+            listFocusBackground: editorBackground,
+            listFocusForeground: settingsHeaderHoverForeground,
+            listHoverForeground: settingsHeaderHoverForeground,
+            listHoverBackground: editorBackground,
+            listInactiveSelectionBackground: editorBackground,
+            listInactiveSelectionForeground: settingsHeaderForeground,
+            listInactiveFocusBackground: editorBackground,
+            listInactiveFocusOutline: editorBackground,
+            treeIndentGuidesStroke: undefined,
+            treeInactiveIndentGuidesStroke: undefined
+        }));
+    }
+};
+TOCTree = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IListService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService))
+], TOCTree));
+export { TOCRenderer, TOCTree, TOCTreeModel, createTOCIterator };

package/dist/vscode/vs/workbench/contrib/preferences/common/preferences.js

@@ -0,0 +1,68 @@
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IPreferencesSearchService = ( createDecorator('preferencesSearchService'));
+const SETTINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS = 'settings.action.clearSearchResults';
+const SETTINGS_EDITOR_COMMAND_SHOW_CONTEXT_MENU = 'settings.action.showContextMenu';
+const SETTINGS_EDITOR_COMMAND_SUGGEST_FILTERS = 'settings.action.suggestFilters';
+const CONTEXT_SETTINGS_EDITOR = ( new RawContextKey('inSettingsEditor', false));
+const CONTEXT_SETTINGS_JSON_EDITOR = ( new RawContextKey('inSettingsJSONEditor', false));
+const CONTEXT_SETTINGS_SEARCH_FOCUS = ( new RawContextKey('inSettingsSearch', false));
+const CONTEXT_TOC_ROW_FOCUS = ( new RawContextKey('settingsTocRowFocus', false));
+const CONTEXT_SETTINGS_ROW_FOCUS = ( new RawContextKey('settingRowFocus', false));
+const CONTEXT_KEYBINDINGS_EDITOR = ( new RawContextKey('inKeybindings', false));
+const CONTEXT_KEYBINDINGS_SEARCH_FOCUS = ( new RawContextKey('inKeybindingsSearch', false));
+const CONTEXT_KEYBINDING_FOCUS = ( new RawContextKey('keybindingFocus', false));
+const CONTEXT_WHEN_FOCUS = ( new RawContextKey('whenFocus', false));
+const CONTEXT_SETTINGS_EDITOR_IN_USER_TAB = ( new RawContextKey('inSettingsEditorUserTab', false));
+const KEYBINDINGS_EDITOR_COMMAND_SEARCH = 'keybindings.editor.searchKeybindings';
+const KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS = 'keybindings.editor.clearSearchResults';
+const KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_HISTORY = 'keybindings.editor.clearSearchHistory';
+const KEYBINDINGS_EDITOR_COMMAND_RECORD_SEARCH_KEYS = 'keybindings.editor.recordSearchKeys';
+const KEYBINDINGS_EDITOR_COMMAND_SORTBY_PRECEDENCE = 'keybindings.editor.toggleSortByPrecedence';
+const KEYBINDINGS_EDITOR_COMMAND_DEFINE = 'keybindings.editor.defineKeybinding';
+const KEYBINDINGS_EDITOR_COMMAND_ADD = 'keybindings.editor.addKeybinding';
+const KEYBINDINGS_EDITOR_COMMAND_DEFINE_WHEN = 'keybindings.editor.defineWhenExpression';
+const KEYBINDINGS_EDITOR_COMMAND_ACCEPT_WHEN = 'keybindings.editor.acceptWhenExpression';
+const KEYBINDINGS_EDITOR_COMMAND_REJECT_WHEN = 'keybindings.editor.rejectWhenExpression';
+const KEYBINDINGS_EDITOR_COMMAND_REMOVE = 'keybindings.editor.removeKeybinding';
+const KEYBINDINGS_EDITOR_COMMAND_RESET = 'keybindings.editor.resetKeybinding';
+const KEYBINDINGS_EDITOR_COMMAND_COPY = 'keybindings.editor.copyKeybindingEntry';
+const KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND = 'keybindings.editor.copyCommandKeybindingEntry';
+const KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND_TITLE = 'keybindings.editor.copyCommandTitle';
+const KEYBINDINGS_EDITOR_COMMAND_SHOW_SIMILAR = 'keybindings.editor.showConflicts';
+const KEYBINDINGS_EDITOR_COMMAND_FOCUS_KEYBINDINGS = 'keybindings.editor.focusKeybindings';
+const KEYBINDINGS_EDITOR_SHOW_DEFAULT_KEYBINDINGS = 'keybindings.editor.showDefaultKeybindings';
+const KEYBINDINGS_EDITOR_SHOW_USER_KEYBINDINGS = 'keybindings.editor.showUserKeybindings';
+const KEYBINDINGS_EDITOR_SHOW_EXTENSION_KEYBINDINGS = 'keybindings.editor.showExtensionKeybindings';
+const MODIFIED_SETTING_TAG = 'modified';
+const EXTENSION_SETTING_TAG = 'ext:';
+const FEATURE_SETTING_TAG = 'feature:';
+const ID_SETTING_TAG = 'id:';
+const LANGUAGE_SETTING_TAG = 'lang:';
+const GENERAL_TAG_SETTING_TAG = 'tag:';
+const POLICY_SETTING_TAG = 'hasPolicy';
+const WORKSPACE_TRUST_SETTING_TAG = 'workspaceTrust';
+const REQUIRE_TRUSTED_WORKSPACE_SETTING_TAG = 'requireTrustedWorkspace';
+let cachedExtensionToggleData;
+async function getExperimentalExtensionToggleData(workbenchAssignmentService, environmentService, productService) {
+    if (cachedExtensionToggleData) {
+        return cachedExtensionToggleData;
+    }
+    const isTreatment = await workbenchAssignmentService.getTreatment('ExtensionToggleSettings');
+    if ((isTreatment || !environmentService.isBuilt) && productService.extensionRecommendations && productService.commonlyUsedSettings) {
+        const settingsEditorRecommendedExtensions = {};
+        ( Object.keys(productService.extensionRecommendations)).forEach(key => {
+            const value = productService.extensionRecommendations[key];
+            if (value.onSettingsEditorOpen) {
+                settingsEditorRecommendedExtensions[key] = value;
+            }
+        });
+        cachedExtensionToggleData = {
+            settingsEditorRecommendedExtensions,
+            commonlyUsed: productService.commonlyUsedSettings
+        };
+        return cachedExtensionToggleData;
+    }
+    return undefined;
+}
+export { CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDINGS_SEARCH_FOCUS, CONTEXT_KEYBINDING_FOCUS, CONTEXT_SETTINGS_EDITOR, CONTEXT_SETTINGS_EDITOR_IN_USER_TAB, CONTEXT_SETTINGS_JSON_EDITOR, CONTEXT_SETTINGS_ROW_FOCUS, CONTEXT_SETTINGS_SEARCH_FOCUS, CONTEXT_TOC_ROW_FOCUS, CONTEXT_WHEN_FOCUS, EXTENSION_SETTING_TAG, FEATURE_SETTING_TAG, GENERAL_TAG_SETTING_TAG, ID_SETTING_TAG, IPreferencesSearchService, KEYBINDINGS_EDITOR_COMMAND_ACCEPT_WHEN, KEYBINDINGS_EDITOR_COMMAND_ADD, KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_HISTORY, KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS, KEYBINDINGS_EDITOR_COMMAND_COPY, KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND, KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND_TITLE, KEYBINDINGS_EDITOR_COMMAND_DEFINE, KEYBINDINGS_EDITOR_COMMAND_DEFINE_WHEN, KEYBINDINGS_EDITOR_COMMAND_FOCUS_KEYBINDINGS, KEYBINDINGS_EDITOR_COMMAND_RECORD_SEARCH_KEYS, KEYBINDINGS_EDITOR_COMMAND_REJECT_WHEN, KEYBINDINGS_EDITOR_COMMAND_REMOVE, KEYBINDINGS_EDITOR_COMMAND_RESET, KEYBINDINGS_EDITOR_COMMAND_SEARCH, KEYBINDINGS_EDITOR_COMMAND_SHOW_SIMILAR, KEYBINDINGS_EDITOR_COMMAND_SORTBY_PRECEDENCE, KEYBINDINGS_EDITOR_SHOW_DEFAULT_KEYBINDINGS, KEYBINDINGS_EDITOR_SHOW_EXTENSION_KEYBINDINGS, KEYBINDINGS_EDITOR_SHOW_USER_KEYBINDINGS, LANGUAGE_SETTING_TAG, MODIFIED_SETTING_TAG, POLICY_SETTING_TAG, REQUIRE_TRUSTED_WORKSPACE_SETTING_TAG, SETTINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS, SETTINGS_EDITOR_COMMAND_SHOW_CONTEXT_MENU, SETTINGS_EDITOR_COMMAND_SUGGEST_FILTERS, WORKSPACE_TRUST_SETTING_TAG, getExperimentalExtensionToggleData };

package/dist/vscode/vs/workbench/contrib/preferences/common/preferencesContribution.js

@@ -0,0 +1,157 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import * as JSONContributionRegistry from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { ITextEditorService } from '../../../services/textfile/common/textEditorService.js';
+import { USE_SPLIT_JSON_SETTING, DEFAULT_SETTINGS_EDITOR_SETTING, FOLDER_SETTINGS_PATH, IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
+const schemaRegistry = ( Registry.as(JSONContributionRegistry.Extensions.JSONContribution));
+let PreferencesContribution = class PreferencesContribution {
+    constructor(modelService, textModelResolverService, preferencesService, languageService, userDataProfileService, workspaceService, configurationService, editorResolverService, textEditorService) {
+        this.modelService = modelService;
+        this.textModelResolverService = textModelResolverService;
+        this.preferencesService = preferencesService;
+        this.languageService = languageService;
+        this.userDataProfileService = userDataProfileService;
+        this.workspaceService = workspaceService;
+        this.configurationService = configurationService;
+        this.editorResolverService = editorResolverService;
+        this.textEditorService = textEditorService;
+        this.settingsListener = this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(USE_SPLIT_JSON_SETTING) || e.affectsConfiguration(DEFAULT_SETTINGS_EDITOR_SETTING)) {
+                this.handleSettingsEditorRegistration();
+            }
+        });
+        this.handleSettingsEditorRegistration();
+        this.start();
+    }
+    handleSettingsEditorRegistration() {
+        dispose(this.editorOpeningListener);
+        if (!!this.configurationService.getValue(USE_SPLIT_JSON_SETTING) || !!this.configurationService.getValue(DEFAULT_SETTINGS_EDITOR_SETTING)) {
+            this.editorOpeningListener = this.editorResolverService.registerEditor('**/settings.json', {
+                id: SideBySideEditorInput.ID,
+                label: ( nls.localize('splitSettingsEditorLabel', "Split Settings Editor")),
+                priority: RegisteredEditorPriority.builtin,
+            }, {}, {
+                createEditorInput: ({ resource, options }) => {
+                    if (isEqual(resource, this.userDataProfileService.currentProfile.settingsResource)) {
+                        return { editor: this.preferencesService.createSplitJsonEditorInput(3 , resource), options };
+                    }
+                    const state = this.workspaceService.getWorkbenchState();
+                    if (state === 2 ) {
+                        const folders = this.workspaceService.getWorkspace().folders;
+                        if (isEqual(resource, folders[0].toResource(FOLDER_SETTINGS_PATH))) {
+                            return { editor: this.preferencesService.createSplitJsonEditorInput(5 , resource), options };
+                        }
+                    }
+                    else if (state === 3 ) {
+                        const folders = this.workspaceService.getWorkspace().folders;
+                        for (const folder of folders) {
+                            if (isEqual(resource, folder.toResource(FOLDER_SETTINGS_PATH))) {
+                                return { editor: this.preferencesService.createSplitJsonEditorInput(6 , resource), options };
+                            }
+                        }
+                    }
+                    return { editor: this.textEditorService.createTextEditor({ resource }), options };
+                }
+            });
+        }
+    }
+    start() {
+        this.textModelResolverService.registerTextModelContentProvider('vscode', {
+            provideTextContent: (uri) => {
+                if (uri.scheme !== 'vscode') {
+                    return null;
+                }
+                if (uri.authority === 'schemas') {
+                    const schemaModel = this.getSchemaModel(uri);
+                    if (schemaModel) {
+                        return Promise.resolve(schemaModel);
+                    }
+                }
+                return Promise.resolve(this.preferencesService.resolveModel(uri));
+            }
+        });
+    }
+    getSchemaModel(uri) {
+        let schema = schemaRegistry.getSchemaContributions().schemas[( uri.toString())];
+        if (schema) {
+            const modelContent = JSON.stringify(schema);
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this.modelService.createModel(modelContent, languageSelection, uri);
+            const disposables = ( new DisposableStore());
+            disposables.add(schemaRegistry.onDidChangeSchema(schemaUri => {
+                if (schemaUri === ( uri.toString())) {
+                    schema = schemaRegistry.getSchemaContributions().schemas[( uri.toString())];
+                    model.setValue(JSON.stringify(schema));
+                }
+            }));
+            disposables.add(model.onWillDispose(() => disposables.dispose()));
+            return model;
+        }
+        return null;
+    }
+    dispose() {
+        dispose(this.editorOpeningListener);
+        dispose(this.settingsListener);
+    }
+};
+PreferencesContribution = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, IPreferencesService)),
+    ( __param(3, ILanguageService)),
+    ( __param(4, IUserDataProfileService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IEditorResolverService)),
+    ( __param(8, ITextEditorService))
+], PreferencesContribution));
+const registry = ( Registry.as(Extensions.Configuration));
+registry.registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    'properties': {
+        'workbench.settings.enableNaturalLanguageSearch': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'enableNaturalLanguageSettingsSearch',
+                "Controls whether to enable the natural language search mode for settings. The natural language search is provided by a Microsoft online service."
+            )),
+            'default': true,
+            'scope': 3 ,
+            'tags': ['usesOnlineServices']
+        },
+        'workbench.settings.settingsSearchTocBehavior': {
+            'type': 'string',
+            'enum': ['hide', 'filter'],
+            'enumDescriptions': [
+                ( nls.localize(
+                    'settingsSearchTocBehavior.hide',
+                    "Hide the Table of Contents while searching."
+                )),
+                ( nls.localize(
+                    'settingsSearchTocBehavior.filter',
+                    "Filter the Table of Contents to just categories that have matching settings. Clicking a category will filter the results to that category."
+                )),
+            ],
+            'description': ( nls.localize(
+                'settingsSearchTocBehavior',
+                "Controls the behavior of the settings editor Table of Contents while searching."
+            )),
+            'default': 'filter',
+            'scope': 3
+        },
+    }
+});
+export { PreferencesContribution };

package/dist/vscode/vs/workbench/contrib/preferences/common/settingsEditorColorRegistry.js

@@ -0,0 +1,67 @@
+import { Color, RGBA } from 'monaco-editor/esm/vs/base/common/color.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, transparent, selectBackground, selectForeground, selectBorder, editorWidgetBorder, checkboxBackground, checkboxForeground, checkboxBorder, inputBackground, inputForeground, inputBorder, listHoverBackground, focusBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { PANEL_BORDER } from '../../../common/theme.js';
+const settingsHeaderForeground = registerColor('settings.headerForeground', { light: '#444444', dark: '#e7e7e7', hcDark: '#ffffff', hcLight: '#292929' }, ( localize(
+    'headerForeground',
+    "The foreground color for a section header or active title."
+)));
+const settingsHeaderHoverForeground = registerColor('settings.settingsHeaderHoverForeground', { light: ( transparent(settingsHeaderForeground, 0.7)), dark: ( transparent(settingsHeaderForeground, 0.7)), hcDark: ( transparent(settingsHeaderForeground, 0.7)), hcLight: ( transparent(settingsHeaderForeground, 0.7)) }, ( localize(
+    'settingsHeaderHoverForeground',
+    "The foreground color for a section header or hovered title."
+)));
+registerColor('settings.modifiedItemIndicator', {
+    light: ( new Color(( new RGBA(102, 175, 224)))),
+    dark: ( new Color(( new RGBA(12, 125, 157)))),
+    hcDark: ( new Color(( new RGBA(0, 73, 122)))),
+    hcLight: ( new Color(( new RGBA(102, 175, 224)))),
+}, ( localize('modifiedItemForeground', "The color of the modified setting indicator.")));
+const settingsHeaderBorder = registerColor('settings.headerBorder', { dark: PANEL_BORDER, light: PANEL_BORDER, hcDark: PANEL_BORDER, hcLight: PANEL_BORDER }, ( localize('settingsHeaderBorder', "The color of the header container border.")));
+const settingsSashBorder = registerColor('settings.sashBorder', { dark: PANEL_BORDER, light: PANEL_BORDER, hcDark: PANEL_BORDER, hcLight: PANEL_BORDER }, ( localize(
+    'settingsSashBorder',
+    "The color of the Settings editor splitview sash border."
+)));
+const settingsSelectBackground = registerColor(`settings.dropdownBackground`, { dark: selectBackground, light: selectBackground, hcDark: selectBackground, hcLight: selectBackground }, ( localize('settingsDropdownBackground', "Settings editor dropdown background.")));
+const settingsSelectForeground = registerColor('settings.dropdownForeground', { dark: selectForeground, light: selectForeground, hcDark: selectForeground, hcLight: selectForeground }, ( localize('settingsDropdownForeground', "Settings editor dropdown foreground.")));
+const settingsSelectBorder = registerColor('settings.dropdownBorder', { dark: selectBorder, light: selectBorder, hcDark: selectBorder, hcLight: selectBorder }, ( localize('settingsDropdownBorder', "Settings editor dropdown border.")));
+const settingsSelectListBorder = registerColor('settings.dropdownListBorder', { dark: editorWidgetBorder, light: editorWidgetBorder, hcDark: editorWidgetBorder, hcLight: editorWidgetBorder }, ( localize(
+    'settingsDropdownListBorder',
+    "Settings editor dropdown list border. This surrounds the options and separates the options from the description."
+)));
+registerColor('settings.checkboxBackground', { dark: checkboxBackground, light: checkboxBackground, hcDark: checkboxBackground, hcLight: checkboxBackground }, ( localize('settingsCheckboxBackground', "Settings editor checkbox background.")));
+registerColor('settings.checkboxForeground', { dark: checkboxForeground, light: checkboxForeground, hcDark: checkboxForeground, hcLight: checkboxForeground }, ( localize('settingsCheckboxForeground', "Settings editor checkbox foreground.")));
+registerColor('settings.checkboxBorder', { dark: checkboxBorder, light: checkboxBorder, hcDark: checkboxBorder, hcLight: checkboxBorder }, ( localize('settingsCheckboxBorder', "Settings editor checkbox border.")));
+const settingsTextInputBackground = registerColor('settings.textInputBackground', { dark: inputBackground, light: inputBackground, hcDark: inputBackground, hcLight: inputBackground }, ( localize('textInputBoxBackground', "Settings editor text input box background.")));
+const settingsTextInputForeground = registerColor('settings.textInputForeground', { dark: inputForeground, light: inputForeground, hcDark: inputForeground, hcLight: inputForeground }, ( localize('textInputBoxForeground', "Settings editor text input box foreground.")));
+const settingsTextInputBorder = registerColor('settings.textInputBorder', { dark: inputBorder, light: inputBorder, hcDark: inputBorder, hcLight: inputBorder }, ( localize('textInputBoxBorder', "Settings editor text input box border.")));
+const settingsNumberInputBackground = registerColor('settings.numberInputBackground', { dark: inputBackground, light: inputBackground, hcDark: inputBackground, hcLight: inputBackground }, ( localize('numberInputBoxBackground', "Settings editor number input box background.")));
+const settingsNumberInputForeground = registerColor('settings.numberInputForeground', { dark: inputForeground, light: inputForeground, hcDark: inputForeground, hcLight: inputForeground }, ( localize('numberInputBoxForeground', "Settings editor number input box foreground.")));
+const settingsNumberInputBorder = registerColor('settings.numberInputBorder', { dark: inputBorder, light: inputBorder, hcDark: inputBorder, hcLight: inputBorder }, ( localize('numberInputBoxBorder', "Settings editor number input box border.")));
+registerColor('settings.focusedRowBackground', {
+    dark: ( transparent(listHoverBackground, .6)),
+    light: ( transparent(listHoverBackground, .6)),
+    hcDark: null,
+    hcLight: null,
+}, ( localize(
+    'focusedRowBackground',
+    "The background color of a settings row when focused."
+)));
+registerColor('settings.rowHoverBackground', {
+    dark: ( transparent(listHoverBackground, .3)),
+    light: ( transparent(listHoverBackground, .3)),
+    hcDark: null,
+    hcLight: null
+}, ( localize(
+    'settings.rowHoverBackground',
+    "The background color of a settings row when hovered."
+)));
+registerColor('settings.focusedRowBorder', {
+    dark: focusBorder,
+    light: focusBorder,
+    hcDark: focusBorder,
+    hcLight: focusBorder
+}, ( localize(
+    'settings.focusedRowBorder',
+    "The color of the row's top and bottom border when the row is focused."
+)));
+export { settingsHeaderBorder, settingsHeaderForeground, settingsHeaderHoverForeground, settingsNumberInputBackground, settingsNumberInputBorder, settingsNumberInputForeground, settingsSashBorder, settingsSelectBackground, settingsSelectBorder, settingsSelectForeground, settingsSelectListBorder, settingsTextInputBackground, settingsTextInputBorder, settingsTextInputForeground };

package/dist/vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { CommandsHistory } from 'monaco-editor/esm/vs/platform/quickinput/browser/commandsQuickAccess.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { MenuId, MenuItemAction, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.js';
@@ -16,6 +17,7 @@ import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configurati
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
 import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
@@ -23,9 +25,9 @@ import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
 import { isFirefox } from 'monaco-editor/esm/vs/base/browser/browser.js';
 import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
 import { ISemanticSimilarityService } from '../../../services/semanticSimilarity/common/semanticSimilarityService.js';
-import { IInteractiveSessionService } from '../../interactiveSession/common/interactiveSessionService.js';
+import { IChatService } from '../../chat/common/chatService.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IInteractiveSessionWidgetService } from '../../interactiveSession/browser/interactiveSessionWidget.js';
+import { IChatWidgetService } from '../../chat/browser/chat.js';
 let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
     get activeTextEditorControl() { return this.editorService.activeTextEditorControl; }
     get defaultFilterValue() {
@@ -34,14 +36,14 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         }
         return undefined;
     }
-    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService, semanticSimilarityService, interactiveSessionService) {
+    constructor(editorService, menuService, extensionService, instantiationService, keybindingService, commandService, telemetryService, dialogService, configurationService, editorGroupService, preferencesService, productService, semanticSimilarityService, chatService) {
         super({
             showAlias: !Language.isDefaultVariant(),
             noResultsPick: (filter) => {
-                const info = this.interactiveSessionService.getProviderInfos()[0];
+                const info = this.chatService.getProviderInfos()[0];
                 return info
                     ? {
-                        label: ( localize('askXInInteractiveSession', "Ask {0}: {1}", info.displayName, filter)),
+                        label: ( localize('askXInChat', "Ask {0}: {1}", info.displayName, filter)),
                         commandId: AskInInteractiveAction.ID,
                         accept: () => commandService.executeCommand(AskInInteractiveAction.ID, filter)
                     }
@@ -59,7 +61,7 @@ let CommandsQuickAccessProvider = class CommandsQuickAccessProvider extends Abst
         this.preferencesService = preferencesService;
         this.productService = productService;
         this.semanticSimilarityService = semanticSimilarityService;
-        this.interactiveSessionService = interactiveSessionService;
+        this.chatService = chatService;
         this.extensionRegistrationRace = raceTimeout(this.extensionService.whenInstalledExtensionsRegistered(), 800);
         this.useSemanticSimilarity = false;
         this._register(configurationService.onDidChangeConfiguration((e) => this.updateOptions(e)));
@@ -192,7 +194,7 @@ CommandsQuickAccessProvider = ( __decorate([
     ( __param(10, IPreferencesService)),
     ( __param(11, IProductService)),
     ( __param(12, ISemanticSimilarityService)),
-    ( __param(13, IInteractiveSessionService))
+    ( __param(13, IChatService))
 ], CommandsQuickAccessProvider));
 class ShowAllCommandsAction extends Action2 {
     constructor() {
@@ -213,39 +215,69 @@ class ShowAllCommandsAction extends Action2 {
     }
 }
 ShowAllCommandsAction.ID = 'workbench.action.showCommands';
+class ClearCommandHistoryAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.clearCommandHistory',
+            title: { value: ( localize('clearCommandHistory', "Clear Command History")), original: 'Clear Command History' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const configurationService = accessor.get(IConfigurationService);
+        const storageService = accessor.get(IStorageService);
+        const dialogService = accessor.get(IDialogService);
+        const commandHistoryLength = CommandsHistory.getConfiguredCommandHistoryLength(configurationService);
+        if (commandHistoryLength > 0) {
+            const { confirmed } = await dialogService.confirm({
+                type: 'warning',
+                message: ( localize(
+                    'confirmClearMessage',
+                    "Do you want to clear the history of recently used commands?"
+                )),
+                detail: ( localize('confirmClearDetail', "This action is irreversible!")),
+                primaryButton: ( localize({ key: 'clearButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Clear"))
+            });
+            if (!confirmed) {
+                return;
+            }
+            CommandsHistory.clearHistory(configurationService, storageService);
+        }
+    }
+}
 class AskInInteractiveAction extends Action2 {
     constructor() {
         super({
             id: AskInInteractiveAction.ID,
-            title: { value: ( localize('askInInteractiveSession', "Ask In Interactive Session")), original: 'Ask In Interactive Session' },
+            title: { value: ( localize('askInChat', "Ask In Chat")), original: 'Ask In Chat' },
             f1: false
         });
     }
     async run(accessor, filter) {
-        const interactiveSessionService = accessor.get(IInteractiveSessionService);
-        const interactiveSessionWidgetService = accessor.get(IInteractiveSessionWidgetService);
+        const chatService = accessor.get(IChatService);
+        const chatWidgetService = accessor.get(IChatWidgetService);
         const logService = accessor.get(ILogService);
         if (!filter) {
             throw new Error('No filter provided.');
         }
         let providerId;
-        const providerInfos = interactiveSessionService.getProviderInfos();
+        const providerInfos = chatService.getProviderInfos();
         switch (providerInfos.length) {
             case 0:
-                throw new Error('No interactive session provider found.');
+                throw new Error('No chat provider found.');
             case 1:
                 providerId = providerInfos[0].id;
                 break;
             default:
-                logService.warn('Multiple interactive session providers found. Using the first one.');
+                logService.warn('Multiple chat providers found. Using the first one.');
                 providerId = providerInfos[0].id;
                 break;
         }
-        const widget = await interactiveSessionWidgetService.revealViewForProvider(providerId);
+        const widget = await chatWidgetService.revealViewForProvider(providerId);
         if (widget?.viewModel) {
-            interactiveSessionService.sendInteractiveRequestToProvider(widget.viewModel.sessionId, { message: filter });
+            chatService.sendRequestToProvider(widget.viewModel.sessionId, { message: filter });
         }
     }
 }
-AskInInteractiveAction.ID = 'workbench.action.askCommandInInteractiveSession';
-export { AskInInteractiveAction, CommandsQuickAccessProvider, ShowAllCommandsAction };
+AskInInteractiveAction.ID = 'workbench.action.askCommandInChat';
+export { AskInInteractiveAction, ClearCommandHistoryAction, CommandsQuickAccessProvider, ShowAllCommandsAction };