@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

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

@@ -0,0 +1,731 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { EventHelper, getDomNodePagePosition } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { SubmenuAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { CodeActionKind } from 'monaco-editor/esm/vs/editor/contrib/codeAction/common/types.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { overrideIdentifiersFromKey, Extensions, OVERRIDE_PROPERTY_REGEX } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { RangeHighlightDecorations } from '../../../browser/codeeditor.js';
+import { settingsEditIcon } from './preferencesIcons.js';
+import { EditPreferenceWidget } from './preferencesWidgets.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { WorkspaceConfigurationEditorModel, DefaultSettingsEditorModel } from '../../../services/preferences/common/preferencesModels.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+let UserSettingsRenderer = class UserSettingsRenderer extends Disposable {
+    constructor(editor, preferencesModel, preferencesService, configurationService, instantiationService) {
+        super();
+        this.editor = editor;
+        this.preferencesModel = preferencesModel;
+        this.preferencesService = preferencesService;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.modelChangeDelayer = ( new Delayer(200));
+        this.settingHighlighter = this._register(instantiationService.createInstance(SettingHighlighter, editor));
+        this.editSettingActionRenderer = this._register(this.instantiationService.createInstance(EditSettingRenderer, this.editor, this.preferencesModel, this.settingHighlighter));
+        this._register(this.editSettingActionRenderer.onUpdateSetting(({ key, value, source }) => this.updatePreference(key, value, source)));
+        this._register(this.editor.getModel().onDidChangeContent(() => this.modelChangeDelayer.trigger(() => this.onModelChanged())));
+        this.unsupportedSettingsRenderer = this._register(instantiationService.createInstance(UnsupportedSettingsRenderer, editor, preferencesModel));
+    }
+    render() {
+        this.editSettingActionRenderer.render(this.preferencesModel.settingsGroups, this.associatedPreferencesModel);
+        this.unsupportedSettingsRenderer.render();
+    }
+    updatePreference(key, value, source) {
+        const overrideIdentifiers = source.overrideOf ? overrideIdentifiersFromKey(source.overrideOf.key) : null;
+        const resource = this.preferencesModel.uri;
+        this.configurationService.updateValue(key, value, { overrideIdentifiers, resource }, this.preferencesModel.configurationTarget)
+            .then(() => this.onSettingUpdated(source));
+    }
+    onModelChanged() {
+        if (!this.editor.hasModel()) {
+            return;
+        }
+        this.render();
+    }
+    onSettingUpdated(setting) {
+        this.editor.focus();
+        setting = this.getSetting(setting);
+        if (setting) {
+            this.editor.setSelection(setting.valueRange);
+            this.settingHighlighter.highlight(setting, true);
+        }
+    }
+    getSetting(setting) {
+        const { key, overrideOf } = setting;
+        if (overrideOf) {
+            const setting = this.getSetting(overrideOf);
+            for (const override of setting.overrides) {
+                if (override.key === key) {
+                    return override;
+                }
+            }
+            return undefined;
+        }
+        return this.preferencesModel.getPreference(key);
+    }
+    focusPreference(setting) {
+        const s = this.getSetting(setting);
+        if (s) {
+            this.settingHighlighter.highlight(s, true);
+            this.editor.setPosition({ lineNumber: s.keyRange.startLineNumber, column: s.keyRange.startColumn });
+        }
+        else {
+            this.settingHighlighter.clear(true);
+        }
+    }
+    clearFocus(setting) {
+        this.settingHighlighter.clear(true);
+    }
+    editPreference(setting) {
+        const editableSetting = this.getSetting(setting);
+        return !!(editableSetting && this.editSettingActionRenderer.activateOnSetting(editableSetting));
+    }
+};
+UserSettingsRenderer = ( __decorate([
+    ( __param(2, IPreferencesService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService))
+], UserSettingsRenderer));
+let WorkspaceSettingsRenderer = class WorkspaceSettingsRenderer extends UserSettingsRenderer {
+    constructor(editor, preferencesModel, preferencesService, configurationService, instantiationService) {
+        super(editor, preferencesModel, preferencesService, configurationService, instantiationService);
+        this.workspaceConfigurationRenderer = this._register(instantiationService.createInstance(WorkspaceConfigurationRenderer, editor, preferencesModel));
+    }
+    render() {
+        super.render();
+        this.workspaceConfigurationRenderer.render();
+    }
+};
+WorkspaceSettingsRenderer = ( __decorate([
+    ( __param(2, IPreferencesService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService))
+], WorkspaceSettingsRenderer));
+let EditSettingRenderer = class EditSettingRenderer extends Disposable {
+    constructor(editor, primarySettingsModel, settingHighlighter, configurationService, instantiationService, contextMenuService) {
+        super();
+        this.editor = editor;
+        this.primarySettingsModel = primarySettingsModel;
+        this.settingHighlighter = settingHighlighter;
+        this.configurationService = configurationService;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.settingsGroups = [];
+        this._onUpdateSetting = ( new Emitter());
+        this.onUpdateSetting = this._onUpdateSetting.event;
+        this.editPreferenceWidgetForCursorPosition = this._register(this.instantiationService.createInstance(EditPreferenceWidget, editor));
+        this.editPreferenceWidgetForMouseMove = this._register(this.instantiationService.createInstance(EditPreferenceWidget, editor));
+        this.toggleEditPreferencesForMouseMoveDelayer = ( new Delayer(75));
+        this._register(this.editPreferenceWidgetForCursorPosition.onClick(e => this.onEditSettingClicked(this.editPreferenceWidgetForCursorPosition, e)));
+        this._register(this.editPreferenceWidgetForMouseMove.onClick(e => this.onEditSettingClicked(this.editPreferenceWidgetForMouseMove, e)));
+        this._register(this.editor.onDidChangeCursorPosition(positionChangeEvent => this.onPositionChanged(positionChangeEvent)));
+        this._register(this.editor.onMouseMove(mouseMoveEvent => this.onMouseMoved(mouseMoveEvent)));
+        this._register(this.editor.onDidChangeConfiguration(() => this.onConfigurationChanged()));
+    }
+    render(settingsGroups, associatedPreferencesModel) {
+        this.editPreferenceWidgetForCursorPosition.hide();
+        this.editPreferenceWidgetForMouseMove.hide();
+        this.settingsGroups = settingsGroups;
+        this.associatedPreferencesModel = associatedPreferencesModel;
+        const settings = this.getSettings(this.editor.getPosition().lineNumber);
+        if (settings.length) {
+            this.showEditPreferencesWidget(this.editPreferenceWidgetForCursorPosition, settings);
+        }
+    }
+    isDefaultSettings() {
+        return this.primarySettingsModel instanceof DefaultSettingsEditorModel;
+    }
+    onConfigurationChanged() {
+        if (!this.editor.getOption(55 )) {
+            this.editPreferenceWidgetForCursorPosition.hide();
+            this.editPreferenceWidgetForMouseMove.hide();
+        }
+    }
+    onPositionChanged(positionChangeEvent) {
+        this.editPreferenceWidgetForMouseMove.hide();
+        const settings = this.getSettings(positionChangeEvent.position.lineNumber);
+        if (settings.length) {
+            this.showEditPreferencesWidget(this.editPreferenceWidgetForCursorPosition, settings);
+        }
+        else {
+            this.editPreferenceWidgetForCursorPosition.hide();
+        }
+    }
+    onMouseMoved(mouseMoveEvent) {
+        const editPreferenceWidget = this.getEditPreferenceWidgetUnderMouse(mouseMoveEvent);
+        if (editPreferenceWidget) {
+            this.onMouseOver(editPreferenceWidget);
+            return;
+        }
+        this.settingHighlighter.clear();
+        this.toggleEditPreferencesForMouseMoveDelayer.trigger(() => this.toggleEditPreferenceWidgetForMouseMove(mouseMoveEvent));
+    }
+    getEditPreferenceWidgetUnderMouse(mouseMoveEvent) {
+        if (mouseMoveEvent.target.type === 2 ) {
+            const line = mouseMoveEvent.target.position.lineNumber;
+            if (this.editPreferenceWidgetForMouseMove.getLine() === line && this.editPreferenceWidgetForMouseMove.isVisible()) {
+                return this.editPreferenceWidgetForMouseMove;
+            }
+            if (this.editPreferenceWidgetForCursorPosition.getLine() === line && this.editPreferenceWidgetForCursorPosition.isVisible()) {
+                return this.editPreferenceWidgetForCursorPosition;
+            }
+        }
+        return undefined;
+    }
+    toggleEditPreferenceWidgetForMouseMove(mouseMoveEvent) {
+        const settings = mouseMoveEvent.target.position ? this.getSettings(mouseMoveEvent.target.position.lineNumber) : null;
+        if (settings && settings.length) {
+            this.showEditPreferencesWidget(this.editPreferenceWidgetForMouseMove, settings);
+        }
+        else {
+            this.editPreferenceWidgetForMouseMove.hide();
+        }
+    }
+    showEditPreferencesWidget(editPreferencesWidget, settings) {
+        const line = settings[0].valueRange.startLineNumber;
+        if (this.editor.getOption(55 ) && this.marginFreeFromOtherDecorations(line)) {
+            editPreferencesWidget.show(line, ( nls.localize('editTtile', "Edit")), settings);
+            const editPreferenceWidgetToHide = editPreferencesWidget === this.editPreferenceWidgetForCursorPosition ? this.editPreferenceWidgetForMouseMove : this.editPreferenceWidgetForCursorPosition;
+            editPreferenceWidgetToHide.hide();
+        }
+    }
+    marginFreeFromOtherDecorations(line) {
+        const decorations = this.editor.getLineDecorations(line);
+        if (decorations) {
+            for (const { options } of decorations) {
+                if (options.glyphMarginClassName && options.glyphMarginClassName.indexOf(ThemeIcon.asClassName(settingsEditIcon)) === -1) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    getSettings(lineNumber) {
+        const configurationMap = this.getConfigurationsMap();
+        return this.getSettingsAtLineNumber(lineNumber).filter(setting => {
+            const configurationNode = configurationMap[setting.key];
+            if (configurationNode) {
+                if (configurationNode.policy && this.configurationService.inspect(setting.key).policyValue !== undefined) {
+                    return false;
+                }
+                if (this.isDefaultSettings()) {
+                    if (setting.key === 'launch') {
+                        return false;
+                    }
+                    return true;
+                }
+                if (configurationNode.type === 'boolean' || configurationNode.enum) {
+                    if (this.primarySettingsModel.configurationTarget !== 6 ) {
+                        return true;
+                    }
+                    if (configurationNode.scope === 4  || configurationNode.scope === 5 ) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        });
+    }
+    getSettingsAtLineNumber(lineNumber) {
+        let index = 0;
+        const settings = [];
+        for (const group of this.settingsGroups) {
+            if (group.range.startLineNumber > lineNumber) {
+                break;
+            }
+            if (lineNumber >= group.range.startLineNumber && lineNumber <= group.range.endLineNumber) {
+                for (const section of group.sections) {
+                    for (const setting of section.settings) {
+                        if (setting.range.startLineNumber > lineNumber) {
+                            break;
+                        }
+                        if (lineNumber >= setting.range.startLineNumber && lineNumber <= setting.range.endLineNumber) {
+                            if (!this.isDefaultSettings() && setting.overrides.length) {
+                                for (const overrideSetting of setting.overrides) {
+                                    if (lineNumber >= overrideSetting.range.startLineNumber && lineNumber <= overrideSetting.range.endLineNumber) {
+                                        settings.push({ ...overrideSetting, index, groupId: group.id });
+                                    }
+                                }
+                            }
+                            else {
+                                settings.push({ ...setting, index, groupId: group.id });
+                            }
+                        }
+                        index++;
+                    }
+                }
+            }
+        }
+        return settings;
+    }
+    onMouseOver(editPreferenceWidget) {
+        this.settingHighlighter.highlight(editPreferenceWidget.preferences[0]);
+    }
+    onEditSettingClicked(editPreferenceWidget, e) {
+        EventHelper.stop(e.event, true);
+        const anchor = { x: e.event.posx, y: e.event.posy };
+        const actions = this.getSettings(editPreferenceWidget.getLine()).length === 1 ? this.getActions(editPreferenceWidget.preferences[0], this.getConfigurationsMap()[editPreferenceWidget.preferences[0].key])
+            : ( editPreferenceWidget.preferences.map(setting => ( new SubmenuAction(
+            `preferences.submenu.${setting.key}`,
+            setting.key,
+            this.getActions(setting, this.getConfigurationsMap()[setting.key])
+        ))));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => actions
+        });
+    }
+    activateOnSetting(setting) {
+        const startLine = setting.keyRange.startLineNumber;
+        const settings = this.getSettings(startLine);
+        if (!settings.length) {
+            return false;
+        }
+        this.editPreferenceWidgetForMouseMove.show(startLine, '', settings);
+        const actions = this.getActions(this.editPreferenceWidgetForMouseMove.preferences[0], this.getConfigurationsMap()[this.editPreferenceWidgetForMouseMove.preferences[0].key]);
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => this.toAbsoluteCoords(( new Position(startLine, 1))),
+            getActions: () => actions
+        });
+        return true;
+    }
+    toAbsoluteCoords(position) {
+        const positionCoords = this.editor.getScrolledVisiblePosition(position);
+        const editorCoords = getDomNodePagePosition(this.editor.getDomNode());
+        const x = editorCoords.left + positionCoords.left;
+        const y = editorCoords.top + positionCoords.top + positionCoords.height;
+        return { x, y: y + 10 };
+    }
+    getConfigurationsMap() {
+        return ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+    }
+    getActions(setting, jsonSchema) {
+        if (jsonSchema.type === 'boolean') {
+            return [{
+                    id: 'truthyValue',
+                    label: 'true',
+                    enabled: true,
+                    run: () => this.updateSetting(setting.key, true, setting)
+                }, {
+                    id: 'falsyValue',
+                    label: 'false',
+                    enabled: true,
+                    run: () => this.updateSetting(setting.key, false, setting)
+                }];
+        }
+        if (jsonSchema.enum) {
+            return ( jsonSchema.enum.map(value => {
+                return {
+                    id: value,
+                    label: JSON.stringify(value),
+                    enabled: true,
+                    run: () => this.updateSetting(setting.key, value, setting)
+                };
+            }));
+        }
+        return this.getDefaultActions(setting);
+    }
+    getDefaultActions(setting) {
+        if (this.isDefaultSettings()) {
+            const settingInOtherModel = this.associatedPreferencesModel.getPreference(setting.key);
+            return [{
+                    id: 'setDefaultValue',
+                    label: settingInOtherModel ? ( nls.localize('replaceDefaultValue', "Replace in Settings")) : ( nls.localize('copyDefaultValue', "Copy to Settings")),
+                    enabled: true,
+                    run: () => this.updateSetting(setting.key, setting.value, setting)
+                }];
+        }
+        return [];
+    }
+    updateSetting(key, value, source) {
+        this._onUpdateSetting.fire({ key, value, source });
+    }
+};
+EditSettingRenderer = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextMenuService))
+], EditSettingRenderer));
+let SettingHighlighter = class SettingHighlighter extends Disposable {
+    constructor(editor, instantiationService) {
+        super();
+        this.editor = editor;
+        this.fixedHighlighter = this._register(instantiationService.createInstance(RangeHighlightDecorations));
+        this.volatileHighlighter = this._register(instantiationService.createInstance(RangeHighlightDecorations));
+    }
+    highlight(setting, fix = false) {
+        this.volatileHighlighter.removeHighlightRange();
+        this.fixedHighlighter.removeHighlightRange();
+        const highlighter = fix ? this.fixedHighlighter : this.volatileHighlighter;
+        highlighter.highlightRange({
+            range: setting.valueRange,
+            resource: this.editor.getModel().uri
+        }, this.editor);
+        this.editor.revealLineInCenterIfOutsideViewport(setting.valueRange.startLineNumber, 0 );
+    }
+    clear(fix = false) {
+        this.volatileHighlighter.removeHighlightRange();
+        if (fix) {
+            this.fixedHighlighter.removeHighlightRange();
+        }
+    }
+};
+SettingHighlighter = ( __decorate([
+    ( __param(1, IInstantiationService))
+], SettingHighlighter));
+let UnsupportedSettingsRenderer = class UnsupportedSettingsRenderer extends Disposable {
+    constructor(editor, settingsEditorModel, markerService, environmentService, configurationService, workspaceTrustManagementService, uriIdentityService, languageFeaturesService, userDataProfileService, userDataProfilesService) {
+        super();
+        this.editor = editor;
+        this.settingsEditorModel = settingsEditorModel;
+        this.markerService = markerService;
+        this.environmentService = environmentService;
+        this.configurationService = configurationService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.uriIdentityService = uriIdentityService;
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.renderingDelayer = ( new Delayer(200));
+        this.codeActions = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+        this._register(this.editor.getModel().onDidChangeContent(() => this.delayedRender()));
+        this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.source === 7 )(() => this.delayedRender()));
+        this._register(languageFeaturesService.codeActionProvider.register({ pattern: settingsEditorModel.uri.path }, this));
+    }
+    delayedRender() {
+        this.renderingDelayer.trigger(() => this.render());
+    }
+    render() {
+        this.codeActions.clear();
+        const markerData = this.generateMarkerData();
+        if (markerData.length) {
+            this.markerService.changeOne('UnsupportedSettingsRenderer', this.settingsEditorModel.uri, markerData);
+        }
+        else {
+            this.markerService.remove('UnsupportedSettingsRenderer', [this.settingsEditorModel.uri]);
+        }
+    }
+    async provideCodeActions(model, range, context, token) {
+        const actions = [];
+        const codeActionsByRange = this.codeActions.get(model.uri);
+        if (codeActionsByRange) {
+            for (const [codeActionsRange, codeActions] of codeActionsByRange) {
+                if (codeActionsRange.containsRange(range)) {
+                    actions.push(...codeActions);
+                }
+            }
+        }
+        return {
+            actions,
+            dispose: () => { }
+        };
+    }
+    generateMarkerData() {
+        const markerData = [];
+        const configurationRegistry = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+        for (const settingsGroup of this.settingsEditorModel.settingsGroups) {
+            for (const section of settingsGroup.sections) {
+                for (const setting of section.settings) {
+                    if (OVERRIDE_PROPERTY_REGEX.test(setting.key)) {
+                        if (setting.overrides) {
+                            this.handleOverrides(setting.overrides, configurationRegistry, markerData);
+                        }
+                        continue;
+                    }
+                    const configuration = configurationRegistry[setting.key];
+                    if (configuration) {
+                        if (this.handlePolicyConfiguration(setting, configuration, markerData)) {
+                            continue;
+                        }
+                        switch (this.settingsEditorModel.configurationTarget) {
+                            case 3 :
+                                this.handleLocalUserConfiguration(setting, configuration, markerData);
+                                break;
+                            case 4 :
+                                this.handleRemoteUserConfiguration(setting, configuration, markerData);
+                                break;
+                            case 5 :
+                                this.handleWorkspaceConfiguration(setting, configuration, markerData);
+                                break;
+                            case 6 :
+                                this.handleWorkspaceFolderConfiguration(setting, configuration, markerData);
+                                break;
+                        }
+                    }
+                    else {
+                        markerData.push(this.gemerateUnknownConfigurationMarker(setting));
+                    }
+                }
+            }
+        }
+        return markerData;
+    }
+    handlePolicyConfiguration(setting, configuration, markerData) {
+        if (!configuration.policy) {
+            return false;
+        }
+        if (this.configurationService.inspect(setting.key).policyValue === undefined) {
+            return false;
+        }
+        if (this.settingsEditorModel.configurationTarget === 7 ) {
+            return false;
+        }
+        markerData.push({
+            severity: MarkerSeverity.Hint,
+            tags: [1 ],
+            ...setting.range,
+            message: ( nls.localize(
+                'unsupportedPolicySetting',
+                "This setting cannot be applied because it is configured in the system policy."
+            ))
+        });
+        return true;
+    }
+    handleOverrides(overrides, configurationRegistry, markerData) {
+        for (const setting of overrides || []) {
+            const configuration = configurationRegistry[setting.key];
+            if (configuration) {
+                if (configuration.scope !== 5 ) {
+                    markerData.push({
+                        severity: MarkerSeverity.Hint,
+                        tags: [1 ],
+                        ...setting.range,
+                        message: ( nls.localize(
+                            'unsupportLanguageOverrideSetting',
+                            "This setting cannot be applied because it is not registered as language override setting."
+                        ))
+                    });
+                }
+            }
+            else {
+                markerData.push(this.gemerateUnknownConfigurationMarker(setting));
+            }
+        }
+    }
+    handleLocalUserConfiguration(setting, configuration, markerData) {
+        if (!this.userDataProfileService.currentProfile.isDefault) {
+            if (isEqual(this.userDataProfilesService.defaultProfile.settingsResource, this.settingsEditorModel.uri) && configuration.scope !== 1 ) {
+                markerData.push({
+                    severity: MarkerSeverity.Hint,
+                    tags: [1 ],
+                    ...setting.range,
+                    message: ( nls.localize(
+                        'defaultProfileSettingWhileNonDefaultActive',
+                        "This setting cannot be applied while a non-default profile is active. It will be applied when the default profile is active."
+                    ))
+                });
+            }
+            else if (isEqual(this.userDataProfileService.currentProfile.settingsResource, this.settingsEditorModel.uri) && configuration.scope === 1 ) {
+                markerData.push(this.generateUnsupportedApplicationSettingMarker(setting));
+            }
+        }
+        if (this.environmentService.remoteAuthority && ((configuration.scope === 2  || configuration.scope === 6) )) {
+            markerData.push({
+                severity: MarkerSeverity.Hint,
+                tags: [1 ],
+                ...setting.range,
+                message: ( nls.localize(
+                    'unsupportedRemoteMachineSetting',
+                    "This setting cannot be applied in this window. It will be applied when you open a local window."
+                ))
+            });
+        }
+    }
+    handleRemoteUserConfiguration(setting, configuration, markerData) {
+        if (configuration.scope === 1 ) {
+            markerData.push(this.generateUnsupportedApplicationSettingMarker(setting));
+        }
+    }
+    handleWorkspaceConfiguration(setting, configuration, markerData) {
+        if (configuration.scope === 1 ) {
+            markerData.push(this.generateUnsupportedApplicationSettingMarker(setting));
+        }
+        if (configuration.scope === 2 ) {
+            markerData.push(this.generateUnsupportedMachineSettingMarker(setting));
+        }
+        if (!this.workspaceTrustManagementService.isWorkspaceTrusted() && configuration.restricted) {
+            const marker = this.generateUntrustedSettingMarker(setting);
+            markerData.push(marker);
+            const codeActions = this.generateUntrustedSettingCodeActions([marker]);
+            this.addCodeActions(marker, codeActions);
+        }
+    }
+    handleWorkspaceFolderConfiguration(setting, configuration, markerData) {
+        if (configuration.scope === 1 ) {
+            markerData.push(this.generateUnsupportedApplicationSettingMarker(setting));
+        }
+        if (configuration.scope === 2 ) {
+            markerData.push(this.generateUnsupportedMachineSettingMarker(setting));
+        }
+        if (configuration.scope === 3 ) {
+            markerData.push({
+                severity: MarkerSeverity.Hint,
+                tags: [1 ],
+                ...setting.range,
+                message: ( nls.localize(
+                    'unsupportedWindowSetting',
+                    "This setting cannot be applied in this workspace. It will be applied when you open the containing workspace folder directly."
+                ))
+            });
+        }
+        if (!this.workspaceTrustManagementService.isWorkspaceTrusted() && configuration.restricted) {
+            const marker = this.generateUntrustedSettingMarker(setting);
+            markerData.push(marker);
+            const codeActions = this.generateUntrustedSettingCodeActions([marker]);
+            this.addCodeActions(marker, codeActions);
+        }
+    }
+    generateUnsupportedApplicationSettingMarker(setting) {
+        return {
+            severity: MarkerSeverity.Hint,
+            tags: [1 ],
+            ...setting.range,
+            message: ( nls.localize(
+                'unsupportedApplicationSetting',
+                "This setting has an application scope and can be set only in the user settings file."
+            ))
+        };
+    }
+    generateUnsupportedMachineSettingMarker(setting) {
+        return {
+            severity: MarkerSeverity.Hint,
+            tags: [1 ],
+            ...setting.range,
+            message: ( nls.localize(
+                'unsupportedMachineSetting',
+                "This setting can only be applied in user settings in local window or in remote settings in remote window."
+            ))
+        };
+    }
+    generateUntrustedSettingMarker(setting) {
+        return {
+            severity: MarkerSeverity.Warning,
+            ...setting.range,
+            message: ( nls.localize(
+                'untrustedSetting',
+                "This setting can only be applied in a trusted workspace."
+            ))
+        };
+    }
+    gemerateUnknownConfigurationMarker(setting) {
+        return {
+            severity: MarkerSeverity.Hint,
+            tags: [1 ],
+            ...setting.range,
+            message: ( nls.localize('unknown configuration setting', "Unknown Configuration Setting"))
+        };
+    }
+    generateUntrustedSettingCodeActions(diagnostics) {
+        return [{
+                title: ( nls.localize('manage workspace trust', "Manage Workspace Trust")),
+                command: {
+                    id: 'workbench.trust.manage',
+                    title: ( nls.localize('manage workspace trust', "Manage Workspace Trust"))
+                },
+                diagnostics,
+                kind: CodeActionKind.QuickFix.value
+            }];
+    }
+    addCodeActions(range, codeActions) {
+        let actions = this.codeActions.get(this.settingsEditorModel.uri);
+        if (!actions) {
+            actions = [];
+            this.codeActions.set(this.settingsEditorModel.uri, actions);
+        }
+        actions.push([Range.lift(range), codeActions]);
+    }
+    dispose() {
+        this.markerService.remove('UnsupportedSettingsRenderer', [this.settingsEditorModel.uri]);
+        this.codeActions.clear();
+        super.dispose();
+    }
+};
+UnsupportedSettingsRenderer = ( __decorate([
+    ( __param(2, IMarkerService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IWorkspaceTrustManagementService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, ILanguageFeaturesService)),
+    ( __param(8, IUserDataProfileService)),
+    ( __param(9, IUserDataProfilesService))
+], UnsupportedSettingsRenderer));
+let WorkspaceConfigurationRenderer = class WorkspaceConfigurationRenderer extends Disposable {
+    constructor(editor, workspaceSettingsEditorModel, workspaceContextService, markerService) {
+        super();
+        this.editor = editor;
+        this.workspaceSettingsEditorModel = workspaceSettingsEditorModel;
+        this.workspaceContextService = workspaceContextService;
+        this.markerService = markerService;
+        this.decorations = this.editor.createDecorationsCollection();
+        this.renderingDelayer = ( new Delayer(200));
+        this._register(this.editor.getModel().onDidChangeContent(() => this.renderingDelayer.trigger(() => this.render())));
+    }
+    render() {
+        const markerData = [];
+        if (this.workspaceContextService.getWorkbenchState() === 3  && this.workspaceSettingsEditorModel instanceof WorkspaceConfigurationEditorModel) {
+            const ranges = [];
+            for (const settingsGroup of this.workspaceSettingsEditorModel.configurationGroups) {
+                for (const section of settingsGroup.sections) {
+                    for (const setting of section.settings) {
+                        if (!WorkspaceConfigurationRenderer.supportedKeys.includes(setting.key)) {
+                            markerData.push({
+                                severity: MarkerSeverity.Hint,
+                                tags: [1 ],
+                                ...setting.range,
+                                message: ( nls.localize('unsupportedProperty', "Unsupported Property"))
+                            });
+                        }
+                    }
+                }
+            }
+            this.decorations.set(( ranges.map(range => this.createDecoration(range))));
+        }
+        if (markerData.length) {
+            this.markerService.changeOne('WorkspaceConfigurationRenderer', this.workspaceSettingsEditorModel.uri, markerData);
+        }
+        else {
+            this.markerService.remove('WorkspaceConfigurationRenderer', [this.workspaceSettingsEditorModel.uri]);
+        }
+    }
+    createDecoration(range) {
+        return {
+            range,
+            options: WorkspaceConfigurationRenderer._DIM_CONFIGURATION_
+        };
+    }
+    dispose() {
+        this.markerService.remove('WorkspaceConfigurationRenderer', [this.workspaceSettingsEditorModel.uri]);
+        this.decorations.clear();
+        super.dispose();
+    }
+};
+WorkspaceConfigurationRenderer.supportedKeys = ['folders', 'tasks', 'launch', 'extensions', 'settings', 'remoteAuthority', 'transient'];
+WorkspaceConfigurationRenderer._DIM_CONFIGURATION_ = ModelDecorationOptions.register({
+    description: 'dim-configuration',
+    stickiness: 1 ,
+    inlineClassName: 'dim-configuration'
+});
+WorkspaceConfigurationRenderer = ( __decorate([
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IMarkerService))
+], WorkspaceConfigurationRenderer));
+export { UserSettingsRenderer, WorkspaceSettingsRenderer };