@codingame/monaco-vscode-update-service-override 2.2.2 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-update-service-override",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@2.2.2",
+    "vscode": "npm:@codingame/monaco-vscode-api@3.0.0",
     "vscode-marked": "npm:marked@=3.0.2"
   }
 }

package/vscode/src/vs/workbench/contrib/markdown/browser/markdownSettingRenderer.js

@@ -0,0 +1,350 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { settingKeyToDisplayFormat } from 'vscode/vscode/vs/workbench/contrib/preferences/browser/settingsTreeModels';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { DefaultSettings } from 'vscode/vscode/vs/workbench/services/preferences/common/preferencesModels';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
+import { ActionViewItem } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+
+const codeSettingRegex = /^<code (codesetting)="([^\s"\:]+)(?::([^"]+))?">/;
+const codeFeatureRegex = /^<span (codefeature)="([^\s"\:]+)(?::([^"]+))?">/;
+let SimpleSettingRenderer = class SimpleSettingRenderer {
+    constructor(_configurationService, _contextMenuService, _preferencesService, _telemetryService, _clipboardService) {
+        this._configurationService = _configurationService;
+        this._contextMenuService = _contextMenuService;
+        this._preferencesService = _preferencesService;
+        this._telemetryService = _telemetryService;
+        this._clipboardService = _clipboardService;
+        this._updatedSettings = ( new Map());
+        this._encounteredSettings = ( new Map());
+        this._featuredSettings = ( new Map());
+        this.settingsGroups = undefined;
+        this._defaultSettings = ( new DefaultSettings([], 2 ));
+    }
+    get featuredSettingStates() {
+        const result = ( new Map());
+        for (const [settingId, value] of this._featuredSettings) {
+            result.set(settingId, this._configurationService.getValue(settingId) === value);
+        }
+        return result;
+    }
+    getHtmlRenderer() {
+        return (html) => {
+            const match = codeSettingRegex.exec(html) ?? codeFeatureRegex.exec(html);
+            if (match && match.length === 4) {
+                const settingId = match[2];
+                const rendered = this.render(settingId, match[3], match[1] === 'codefeature');
+                if (rendered) {
+                    html = html.replace(codeSettingRegex, rendered);
+                }
+            }
+            return html;
+        };
+    }
+    settingToUriString(settingId, value) {
+        return `${Schemas.codeSetting}://${settingId}${value ? `/${value}` : ''}`;
+    }
+    featureToUriString(settingId, value) {
+        return `${Schemas.codeFeature}://${settingId}${value ? `/${value}` : ''}`;
+    }
+    getSetting(settingId) {
+        if (!this.settingsGroups) {
+            this.settingsGroups = this._defaultSettings.getSettingsGroups();
+        }
+        if (( this._encounteredSettings.has(settingId))) {
+            return this._encounteredSettings.get(settingId);
+        }
+        for (const group of this.settingsGroups) {
+            for (const section of group.sections) {
+                for (const setting of section.settings) {
+                    if (setting.key === settingId) {
+                        this._encounteredSettings.set(settingId, setting);
+                        return setting;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    parseValue(settingId, value) {
+        if (value === 'undefined' || value === '') {
+            return undefined;
+        }
+        const setting = this.getSetting(settingId);
+        if (!setting) {
+            return value;
+        }
+        switch (setting.type) {
+            case 'boolean':
+                return value === 'true';
+            case 'number':
+                return parseInt(value, 10);
+            case 'string':
+            default:
+                return value;
+        }
+    }
+    render(settingId, newValue, asFeature) {
+        const setting = this.getSetting(settingId);
+        if (!setting) {
+            return '';
+        }
+        if (asFeature) {
+            return this.renderFeature(setting, newValue);
+        }
+        else {
+            return this.renderSetting(setting, newValue);
+        }
+    }
+    viewInSettingsMessage(settingId, alreadyDisplayed) {
+        if (alreadyDisplayed) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+                'viewInSettings',
+                "View in Settings"
+            ));
+        }
+        else {
+            const displayName = settingKeyToDisplayFormat(settingId);
+            return ( localizeWithPath(
+                'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+                'viewInSettingsDetailed',
+                "View \"{0}: {1}\" in Settings",
+                displayName.category,
+                displayName.label
+            ));
+        }
+    }
+    restorePreviousSettingMessage(settingId) {
+        const displayName = settingKeyToDisplayFormat(settingId);
+        return ( localizeWithPath(
+            'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+            'restorePreviousValue',
+            "Restore value of \"{0}: {1}\"",
+            displayName.category,
+            displayName.label
+        ));
+    }
+    booleanSettingMessage(setting, booleanValue) {
+        const currentValue = this._configurationService.getValue(setting.key);
+        if (currentValue === booleanValue || (currentValue === undefined && setting.value === booleanValue)) {
+            return undefined;
+        }
+        const displayName = settingKeyToDisplayFormat(setting.key);
+        if (booleanValue) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+                'trueMessage',
+                "Enable \"{0}: {1}\"",
+                displayName.category,
+                displayName.label
+            ));
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+                'falseMessage',
+                "Disable \"{0}: {1}\"",
+                displayName.category,
+                displayName.label
+            ));
+        }
+    }
+    stringSettingMessage(setting, stringValue) {
+        const currentValue = this._configurationService.getValue(setting.key);
+        if (currentValue === stringValue || (currentValue === undefined && setting.value === stringValue)) {
+            return undefined;
+        }
+        const displayName = settingKeyToDisplayFormat(setting.key);
+        return ( localizeWithPath(
+            'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+            'stringValue',
+            "Set \"{0}: {1}\" to \"{2}\"",
+            displayName.category,
+            displayName.label,
+            stringValue
+        ));
+    }
+    numberSettingMessage(setting, numberValue) {
+        const currentValue = this._configurationService.getValue(setting.key);
+        if (currentValue === numberValue || (currentValue === undefined && setting.value === numberValue)) {
+            return undefined;
+        }
+        const displayName = settingKeyToDisplayFormat(setting.key);
+        return ( localizeWithPath(
+            'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+            'numberValue',
+            "Set \"{0}: {1}\" to {2}",
+            displayName.category,
+            displayName.label,
+            numberValue
+        ));
+    }
+    renderSetting(setting, newValue) {
+        const href = this.settingToUriString(setting.key, newValue);
+        const title = ( localizeWithPath(
+            'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+            'changeSettingTitle',
+            "View or change setting"
+        ));
+        return `<code tabindex="0"><a href="${href}" class="codesetting" title="${title}" aria-role="button"><svg width="14" height="14" viewBox="0 0 15 15" xmlns="http://www.w3.org/2000/svg" fill="currentColor"><path d="M9.1 4.4L8.6 2H7.4l-.5 2.4-.7.3-2-1.3-.9.8 1.3 2-.2.7-2.4.5v1.2l2.4.5.3.8-1.3 2 .8.8 2-1.3.8.3.4 2.3h1.2l.5-2.4.8-.3 2 1.3.8-.8-1.3-2 .3-.8 2.3-.4V7.4l-2.4-.5-.3-.8 1.3-2-.8-.8-2 1.3-.7-.2zM9.4 1l.5 2.4L12 2.1l2 2-1.4 2.1 2.4.4v2.8l-2.4.5L14 12l-2 2-2.1-1.4-.5 2.4H6.6l-.5-2.4L4 13.9l-2-2 1.4-2.1L1 9.4V6.6l2.4-.5L2.1 4l2-2 2.1 1.4.4-2.4h2.8zm.6 7c0 1.1-.9 2-2 2s-2-.9-2-2 .9-2 2-2 2 .9 2 2zM8 9c.6 0 1-.4 1-1s-.4-1-1-1-1 .4-1 1 .4 1 1 1z"/></svg>
+			<span class="separator"></span>
+			<span class="setting-name">${setting.key}</span>
+		</a></code><code>`;
+    }
+    renderFeature(setting, newValue) {
+        const href = this.featureToUriString(setting.key, newValue);
+        const parsedValue = this.parseValue(setting.key, newValue);
+        const isChecked = this._configurationService.getValue(setting.key) === parsedValue;
+        this._featuredSettings.set(setting.key, parsedValue);
+        const title = ( localizeWithPath(
+            'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+            'changeFeatureTitle',
+            "Toggle feature with setting {0}",
+            setting.key
+        ));
+        return `<span><div class="codefeature-container"><input id="${setting.key}" class="hiddenCheck" type="checkbox" ${isChecked ? 'checked' : ''}><span class="codefeature"><a href="${href}" class="toggle" title="${title}" role="checkbox" aria-checked="${isChecked ? 'true' : 'false'}"></a></span><span class="title"></span></div>`;
+    }
+    getSettingMessage(setting, newValue) {
+        if (setting.type === 'boolean') {
+            return this.booleanSettingMessage(setting, newValue);
+        }
+        else if (setting.type === 'string') {
+            return this.stringSettingMessage(setting, newValue);
+        }
+        else if (setting.type === 'number') {
+            return this.numberSettingMessage(setting, newValue);
+        }
+        return undefined;
+    }
+    async restoreSetting(settingId) {
+        const userOriginalSettingValue = this._updatedSettings.get(settingId);
+        this._updatedSettings.delete(settingId);
+        return this._configurationService.updateValue(settingId, userOriginalSettingValue, 2 );
+    }
+    async setSetting(settingId, currentSettingValue, newSettingValue) {
+        this._updatedSettings.set(settingId, currentSettingValue);
+        return this._configurationService.updateValue(settingId, newSettingValue, 2 );
+    }
+    getActions(uri) {
+        if (uri.scheme !== Schemas.codeSetting) {
+            return;
+        }
+        const actions = [];
+        const settingId = uri.authority;
+        const newSettingValue = this.parseValue(uri.authority, uri.path.substring(1));
+        const currentSettingValue = this._configurationService.inspect(settingId).userValue;
+        if ((newSettingValue !== undefined) && newSettingValue === currentSettingValue && ( this._updatedSettings.has(settingId))) {
+            const restoreMessage = this.restorePreviousSettingMessage(settingId);
+            actions.push({
+                class: undefined,
+                id: 'restoreSetting',
+                enabled: true,
+                tooltip: restoreMessage,
+                label: restoreMessage,
+                run: () => {
+                    return this.restoreSetting(settingId);
+                }
+            });
+        }
+        else if (newSettingValue !== undefined) {
+            const setting = this.getSetting(settingId);
+            const trySettingMessage = setting ? this.getSettingMessage(setting, newSettingValue) : undefined;
+            if (setting && trySettingMessage) {
+                actions.push({
+                    class: undefined,
+                    id: 'trySetting',
+                    enabled: currentSettingValue !== newSettingValue,
+                    tooltip: trySettingMessage,
+                    label: trySettingMessage,
+                    run: () => {
+                        this.setSetting(settingId, currentSettingValue, newSettingValue);
+                    }
+                });
+            }
+        }
+        const viewInSettingsMessage = this.viewInSettingsMessage(settingId, actions.length > 0);
+        actions.push({
+            class: undefined,
+            enabled: true,
+            id: 'viewInSettings',
+            tooltip: viewInSettingsMessage,
+            label: viewInSettingsMessage,
+            run: () => {
+                return this._preferencesService.openApplicationSettings({ query: `@id:${settingId}` });
+            }
+        });
+        actions.push({
+            class: undefined,
+            enabled: true,
+            id: 'copySettingId',
+            tooltip: ( localizeWithPath(
+                'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+                'copySettingId',
+                "Copy Setting ID"
+            )),
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/markdown/browser/markdownSettingRenderer',
+                'copySettingId',
+                "Copy Setting ID"
+            )),
+            run: () => {
+                this._clipboardService.writeText(settingId);
+            }
+        });
+        return actions;
+    }
+    showContextMenu(uri, x, y) {
+        const actions = this.getActions(uri);
+        if (!actions) {
+            return;
+        }
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => ({ x, y }),
+            getActions: () => actions,
+            getActionViewItem: (action) => {
+                return ( new ActionViewItem(action, action, { label: true }));
+            },
+        });
+    }
+    async setFeatureState(uri) {
+        const settingId = uri.authority;
+        const newSettingValue = this.parseValue(uri.authority, uri.path.substring(1));
+        let valueToSetSetting;
+        if (( this._updatedSettings.has(settingId))) {
+            valueToSetSetting = this._updatedSettings.get(settingId);
+            this._updatedSettings.delete(settingId);
+        }
+        else if (newSettingValue !== this._configurationService.getValue(settingId)) {
+            valueToSetSetting = newSettingValue;
+        }
+        else {
+            valueToSetSetting = undefined;
+        }
+        await this._configurationService.updateValue(settingId, valueToSetSetting, 2 );
+    }
+    async updateSetting(uri, x, y) {
+        if (uri.scheme === Schemas.codeSetting) {
+            this._telemetryService.publicLog2('releaseNotesSettingAction', {
+                settingId: uri.authority
+            });
+            return this.showContextMenu(uri, x, y);
+        }
+        else if (uri.scheme === Schemas.codeFeature) {
+            return this.setFeatureState(uri);
+        }
+    }
+};
+SimpleSettingRenderer = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IPreferencesService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IClipboardService))
+], SimpleSettingRenderer));
+
+export { SimpleSettingRenderer };

package/vscode/src/vs/workbench/contrib/update/browser/releaseNotesEditor.js

@@ -24,9 +24,13 @@ import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extension
 import { supportsTelemetry, getTelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { SimpleSettingRenderer } from '../../markdown/browser/markdownSettingRenderer.js';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 
 let ReleaseNotesManager = class ReleaseNotesManager {
-    constructor(_environmentService, _keybindingService, _languageService, _openerService, _requestService, _configurationService, _editorService, _editorGroupService, _webviewWorkbenchService, _extensionService, _productService) {
+    constructor(_environmentService, _keybindingService, _languageService, _openerService, _requestService, _configurationService, _editorService, _editorGroupService, _codeEditorService, _webviewWorkbenchService, _extensionService, _productService, _instantiationService) {
         this._environmentService = _environmentService;
         this._keybindingService = _keybindingService;
         this._languageService = _languageService;
@@ -35,26 +39,34 @@ let ReleaseNotesManager = class ReleaseNotesManager {
         this._configurationService = _configurationService;
         this._editorService = _editorService;
         this._editorGroupService = _editorGroupService;
+        this._codeEditorService = _codeEditorService;
         this._webviewWorkbenchService = _webviewWorkbenchService;
         this._extensionService = _extensionService;
         this._productService = _productService;
+        this._instantiationService = _instantiationService;
         this._releaseNotesCache = ( new Map());
         this._currentReleaseNotes = undefined;
         this.disposables = ( new DisposableStore());
-        TokenizationRegistry.onDidChange(async () => {
-            if (!this._currentReleaseNotes || !this._lastText) {
-                return;
-            }
-            const html = await this.renderBody(this._lastText);
-            if (this._currentReleaseNotes) {
-                this._currentReleaseNotes.webview.setHtml(html);
-            }
+        TokenizationRegistry.onDidChange(() => {
+            return this.updateHtml();
         });
         _configurationService.onDidChangeConfiguration(this.onDidChangeConfiguration, this, this.disposables);
         _webviewWorkbenchService.onDidChangeActiveWebviewEditor(this.onDidChangeActiveWebviewEditor, this, this.disposables);
+        this._simpleSettingRenderer = this._instantiationService.createInstance(SimpleSettingRenderer);
+    }
+    async updateHtml() {
+        if (!this._currentReleaseNotes || !this._lastText) {
+            return;
+        }
+        const captureScroll = this.scrollPosition;
+        const html = await this.renderBody(this._lastText);
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.webview.setHtml(html);
+            this._currentReleaseNotes.webview.postMessage({ type: 'setScroll', value: { scrollPosition: captureScroll } });
+        }
     }
-    async show(version) {
-        const releaseNoteText = await this.loadReleaseNotes(version);
+    async show(version, useCurrentFile) {
+        const releaseNoteText = await this.loadReleaseNotes(version, useCurrentFile);
         this._lastText = releaseNoteText;
         const html = await this.renderBody(releaseNoteText);
         const title = ( localizeWithPath(
@@ -89,6 +101,14 @@ let ReleaseNotesManager = class ReleaseNotesManager {
                 if (e.message.type === 'showReleaseNotes') {
                     this._configurationService.updateValue('update.showReleaseNotes', e.message.value);
                 }
+                else if (e.message.type === 'scroll') {
+                    this.scrollPosition = e.message.value.scrollPosition;
+                }
+                else if (e.message.type === 'clickSetting') {
+                    const x = this._currentReleaseNotes?.webview.container.offsetLeft + e.message.value.x;
+                    const y = this._currentReleaseNotes?.webview.container.offsetTop + e.message.value.y;
+                    this._simpleSettingRenderer.updateSetting(( URI.parse(e.message.value.uri)), x, y);
+                }
             }));
             disposables.add(this._currentReleaseNotes.onWillDispose(() => {
                 disposables.dispose();
@@ -98,7 +118,7 @@ let ReleaseNotesManager = class ReleaseNotesManager {
         }
         return true;
     }
-    async loadReleaseNotes(version) {
+    async loadReleaseNotes(version, useCurrentFile) {
         const match = /^(\d+\.\d+)\./.exec(version);
         if (!match) {
             throw new Error('not found');
@@ -150,7 +170,13 @@ let ReleaseNotesManager = class ReleaseNotesManager {
         const fetchReleaseNotes = async () => {
             let text;
             try {
-                text = await asTextOrError(await this._requestService.request({ url }, CancellationToken.None));
+                if (useCurrentFile) {
+                    const file = this._codeEditorService.getActiveCodeEditor()?.getModel()?.getValue();
+                    text = file ? file.substring(file.indexOf('#')) : undefined;
+                }
+                else {
+                    text = await asTextOrError(await this._requestService.request({ url }, CancellationToken.None));
+                }
             }
             catch {
                 throw new Error('Failed to fetch release notes');
@@ -160,6 +186,9 @@ let ReleaseNotesManager = class ReleaseNotesManager {
             }
             return patchKeybindings(text);
         };
+        if (useCurrentFile) {
+            return fetchReleaseNotes();
+        }
         if (!( this._releaseNotesCache.has(version))) {
             this._releaseNotesCache.set(version, (async () => {
                 try {
@@ -173,10 +202,13 @@ let ReleaseNotesManager = class ReleaseNotesManager {
         }
         return this._releaseNotesCache.get(version);
     }
-    onDidClickLink(uri) {
-        this.addGAParameters(uri, 'ReleaseNotes')
-            .then(updated => this._openerService.open(updated))
-            .then(undefined, onUnexpectedError);
+    async onDidClickLink(uri) {
+        if (uri.scheme === Schemas.codeSetting || uri.scheme === Schemas.codeFeature) ;
+        else {
+            this.addGAParameters(uri, 'ReleaseNotes')
+                .then(updated => this._openerService.open(updated, { allowCommands: ['workbench.action.openSettings'] }))
+                .then(undefined, onUnexpectedError);
+        }
     }
     async addGAParameters(uri, origin, experiment = '1') {
         if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
@@ -188,7 +220,7 @@ let ReleaseNotesManager = class ReleaseNotesManager {
     }
     async renderBody(text) {
         const nonce = generateUuid();
-        const content = await renderMarkdownDocument(text, this._extensionService, this._languageService, false);
+        const content = await renderMarkdownDocument(text, this._extensionService, this._languageService, false, undefined, undefined, this._simpleSettingRenderer);
         const colorMap = TokenizationRegistry.getColorMap();
         const css = colorMap ? generateTokensCSSForColorMap(colorMap) : '';
         const showReleaseNotes = Boolean(this._configurationService.getValue('update.showReleaseNotes'));
@@ -201,6 +233,157 @@ let ReleaseNotesManager = class ReleaseNotesManager {
 				<style nonce="${nonce}">
 					${DEFAULT_MARKDOWN_STYLES}
 					${css}
+
+					/* codesetting */
+
+					code:has(.codesetting)+code {
+						display: none;
+					}
+
+					code:has(.codesetting) {
+						background-color: var(--vscode-textPreformat-background);
+						color: var(--vscode-textPreformat-foreground);
+						padding-left: 1px;
+						margin-right: 3px;
+						padding-right: 0px;
+					}
+
+					code:has(.codesetting):focus {
+						border: 1px solid var(--vscode-button-border, transparent);
+					}
+
+					.codesetting {
+						color: var(--vscode-textPreformat-foreground);
+						padding: 0px 1px 1px 0px;
+						font-size: 0px;
+						overflow: hidden;
+						text-overflow: ellipsis;
+						outline-offset: 2px !important;
+						box-sizing: border-box;
+						text-align: center;
+						cursor: pointer;
+						display: inline;
+						margin-right: 3px;
+					}
+					.codesetting svg {
+						font-size: 12px;
+						text-align: center;
+						cursor: pointer;
+						border: 1px solid var(--vscode-button-secondaryBorder, transparent);
+						outline: 1px solid transparent;
+						line-height: 9px;
+						margin-bottom: -5px;
+						padding-left: 0px;
+						padding-top: 2px;
+						padding-bottom: 2px;
+						padding-right: 2px;
+						display: inline-block;
+						text-decoration: none;
+						text-rendering: auto;
+						text-transform: none;
+						-webkit-font-smoothing: antialiased;
+						-moz-osx-font-smoothing: grayscale;
+						user-select: none;
+						-webkit-user-select: none;
+					}
+					.codesetting .setting-name {
+						font-size: 13px;
+						padding-left: 2px;
+						padding-right: 3px;
+						padding-top: 1px;
+						padding-bottom: 1px;
+						margin-left: -5px;
+						margin-top: -3px;
+					}
+					.codesetting:hover {
+						color: var(--vscode-textPreformat-foreground) !important;
+						text-decoration: none !important;
+					}
+					code:has(.codesetting):hover {
+						filter: brightness(140%);
+						text-decoration: none !important;
+					}
+					.codesetting:focus {
+						outline: 0 !important;
+						text-decoration: none !important;
+						color: var(--vscode-button-hoverForeground) !important;
+					}
+					.codesetting .separator {
+						width: 1px;
+						height: 14px;
+						margin-bottom: -3px;
+						display: inline-block;
+						background-color: var(--vscode-editor-background);
+						font-size: 12px;
+						margin-right: 8px;
+					}
+
+					/* codefeature */
+
+					.codefeature-container {
+						display: flex;
+					}
+
+					.codefeature {
+						position: relative;
+						display: inline-block;
+						width: 46px;
+						height: 24px;
+					}
+
+					.codefeature-container input {
+						display: none;
+					}
+
+					.toggle {
+						position: absolute;
+						cursor: pointer;
+						top: 0;
+						left: 0;
+						right: 0;
+						bottom: 0;
+						background-color: var(--vscode-button-background);
+						transition: .4s;
+						border-radius: 24px;
+					}
+
+					.toggle:before {
+						position: absolute;
+						content: "";
+						height: 16px;
+						width: 16px;
+						left: 4px;
+						bottom: 4px;
+						background-color: var(--vscode-editor-foreground);
+						transition: .4s;
+						border-radius: 50%;
+					}
+
+					input:checked+.codefeature > .toggle:before {
+						transform: translateX(22px);
+					}
+
+					.codefeature-container:has(input) .title {
+						line-height: 30px;
+						padding-left: 4px;
+						font-weight: bold;
+					}
+
+					.codefeature-container:has(input:checked) .title:after {
+						content: "${( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'disableFeature',
+            "Disable this feature"
+        ))}";
+					}
+					.codefeature-container:has(input:not(:checked)) .title:after {
+						content: "${( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'enableFeature',
+            "Enable this feature"
+        ))}";
+					}
+
 					header { display: flex; align-items: center; padding-top: 1em; }
 				</style>
 			</head>
@@ -237,6 +420,49 @@ let ReleaseNotesManager = class ReleaseNotesManager {
 					window.addEventListener('message', event => {
 						if (event.data.type === 'showReleaseNotes') {
 							input.checked = event.data.value;
+						} else if (event.data.type === 'setScroll') {
+							window.scrollTo(event.data.value.scrollPosition.x, event.data.value.scrollPosition.y);
+						} else if (event.data.type === 'setFeaturedSettings') {
+							for (const [settingId, value] of event.data.value) {
+								const setting = document.getElementById(settingId);
+								if (setting instanceof HTMLInputElement) {
+									setting.checked = value;
+								}
+							}
+						}
+					});
+
+					window.onscroll = () => {
+						vscode.postMessage({
+							type: 'scroll',
+							value: {
+								scrollPosition: {
+									x: window.scrollX,
+									y: window.scrollY
+								}
+							}
+						});
+					};
+
+					window.addEventListener('click', event => {
+						const href = event.target.href ?? event.target.parentElement.href ?? event.target.parentElement.parentElement?.href;
+						if (href && (href.startsWith('${Schemas.codeSetting}') || href.startsWith('${Schemas.codeFeature}'))) {
+							vscode.postMessage({ type: 'clickSetting', value: { uri: href, x: event.clientX, y: event.clientY }});
+							if (href.startsWith('${Schemas.codeFeature}')) {
+								const featureInput = event.target.parentElement.previousSibling;
+								if (featureInput instanceof HTMLInputElement) {
+									featureInput.checked = !featureInput.checked;
+								}
+							}
+						}
+					});
+
+					window.addEventListener('keypress', event => {
+						if (event.keyCode === 13) {
+							if (event.target.children.length > 0 && event.target.children[0].href) {
+								const clientRect = event.target.getBoundingClientRect();
+								vscode.postMessage({ type: 'clickSetting', value: { uri: event.target.children[0].href, x: clientRect.right , y: clientRect.bottom }});
+							}
 						}
 					});
 
@@ -249,15 +475,16 @@ let ReleaseNotesManager = class ReleaseNotesManager {
     }
     onDidChangeConfiguration(e) {
         if (e.affectsConfiguration('update.showReleaseNotes')) {
-            this.updateWebview();
+            this.updateCheckboxWebview();
         }
     }
     onDidChangeActiveWebviewEditor(input) {
         if (input && input === this._currentReleaseNotes) {
-            this.updateWebview();
+            this.updateCheckboxWebview();
+            this.updateFeaturedSettingsWebview();
         }
     }
-    updateWebview() {
+    updateCheckboxWebview() {
         if (this._currentReleaseNotes) {
             this._currentReleaseNotes.webview.postMessage({
                 type: 'showReleaseNotes',
@@ -265,6 +492,14 @@ let ReleaseNotesManager = class ReleaseNotesManager {
             });
         }
     }
+    updateFeaturedSettingsWebview() {
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.webview.postMessage({
+                type: 'setFeaturedSettings',
+                value: this._simpleSettingRenderer.featuredSettingStates
+            });
+        }
+    }
 };
 ReleaseNotesManager = ( __decorate([
     ( __param(0, IEnvironmentService)),
@@ -275,9 +510,11 @@ ReleaseNotesManager = ( __decorate([
     ( __param(5, IConfigurationService)),
     ( __param(6, IEditorService)),
     ( __param(7, IEditorGroupsService)),
-    ( __param(8, IWebviewWorkbenchService)),
-    ( __param(9, IExtensionService)),
-    ( __param(10, IProductService))
+    ( __param(8, ICodeEditorService)),
+    ( __param(9, IWebviewWorkbenchService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, IProductService)),
+    ( __param(12, IInstantiationService))
 ], ReleaseNotesManager));
 
 export { ReleaseNotesManager };

package/vscode/src/vs/workbench/contrib/update/browser/update.contribution.js

@@ -1,5 +1,5 @@
 import '../../../../platform/update/common/update.config.contribution.js';
-import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
@@ -11,7 +11,7 @@ import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/c
 import { isWindows } from 'vscode/vscode/vs/base/common/platform';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { mnemonicButtonLabel } from 'vscode/vscode/vs/base/common/labels';
-import { ShowCurrentReleaseNotesActionId } from 'vscode/vscode/vs/workbench/contrib/update/common/update';
+import { ShowCurrentReleaseNotesActionId, ShowCurrentReleaseNotesFromCurrentFileActionId } from 'vscode/vscode/vs/workbench/contrib/update/common/update';
 import { IsWebContext } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
@@ -28,7 +28,7 @@ class ShowCurrentReleaseNotesAction extends Action2 {
         super({
             id: ShowCurrentReleaseNotesActionId,
             title: {
-                value: ( localizeWithPath(
+                ...( localize2WithPath(
                     'vs/workbench/contrib/update/browser/update.contribution',
                     'showReleaseNotes',
                     "Show Release Notes"
@@ -38,7 +38,6 @@ class ShowCurrentReleaseNotesAction extends Action2 {
                     { key: 'mshowReleaseNotes', comment: ['&& denotes a mnemonic'] },
                     "Show &&Release Notes"
                 )),
-                original: 'Show Release Notes'
             },
             category: { value: product.nameShort, original: product.nameShort },
             f1: true,
@@ -56,7 +55,7 @@ class ShowCurrentReleaseNotesAction extends Action2 {
         const productService = accessor.get(IProductService);
         const openerService = accessor.get(IOpenerService);
         try {
-            await showReleaseNotesInEditor(instantiationService, productService.version);
+            await showReleaseNotesInEditor(instantiationService, productService.version, false);
         }
         catch (err) {
             if (productService.releaseNotesUrl) {
@@ -68,7 +67,44 @@ class ShowCurrentReleaseNotesAction extends Action2 {
         }
     }
 }
+class ShowCurrentReleaseNotesFromCurrentFileAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowCurrentReleaseNotesFromCurrentFileActionId,
+            title: {
+                ...( localize2WithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    'showReleaseNotesCurrentFile',
+                    "Open Current File as Release Notes"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    { key: 'mshowReleaseNotes', comment: ['&& denotes a mnemonic'] },
+                    "Show &&Release Notes"
+                )),
+            },
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'developerCategory',
+                "Developer"
+            )),
+            f1: true,
+            precondition: RELEASE_NOTES_URL
+        });
+    }
+    async run(accessor) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const productService = accessor.get(IProductService);
+        try {
+            await showReleaseNotesInEditor(instantiationService, productService.version, true);
+        }
+        catch (err) {
+            throw new Error(localizeWithPath('vs/workbench/contrib/update/browser/update.contribution', 'releaseNotesFromFileNone', "Cannot open the current file as Release Notes"));
+        }
+    }
+}
 registerAction2(ShowCurrentReleaseNotesAction);
+registerAction2(ShowCurrentReleaseNotesFromCurrentFileAction);
 class CheckForUpdateAction extends Action2 {
     constructor() {
         super({
@@ -147,15 +183,12 @@ class DownloadAction extends Action2 {
     constructor() {
         super({
             id: DownloadAction.ID,
-            title: {
-                value: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update.contribution',
-                    'openDownloadPage',
-                    "Download {0}",
-                    product.nameLong
-                )),
-                original: `Download ${product.downloadUrl}`
-            },
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'openDownloadPage',
+                "Download {0}",
+                product.nameLong
+            )),
             precondition: ( ContextKeyExpr.and(IsWebContext, DOWNLOAD_URL)),
             f1: true,
             menu: [{
@@ -218,4 +251,4 @@ if (isWindows) {
     registerAction2(DeveloperApplyUpdateAction);
 }
 
-export { CheckForUpdateAction, ShowCurrentReleaseNotesAction };
+export { CheckForUpdateAction, ShowCurrentReleaseNotesAction, ShowCurrentReleaseNotesFromCurrentFileAction };

package/vscode/src/vs/workbench/contrib/update/browser/update.js

@@ -33,11 +33,11 @@ const MAJOR_MINOR_UPDATE_AVAILABLE = ( new RawContextKey('majorMinorUpdateAvaila
 const RELEASE_NOTES_URL = ( new RawContextKey('releaseNotesUrl', ''));
 const DOWNLOAD_URL = ( new RawContextKey('downloadUrl', ''));
 let releaseNotesManager = undefined;
-function showReleaseNotesInEditor(instantiationService, version) {
+function showReleaseNotesInEditor(instantiationService, version, useCurrentFile) {
     if (!releaseNotesManager) {
         releaseNotesManager = instantiationService.createInstance(ReleaseNotesManager);
     }
-    return releaseNotesManager.show(version);
+    return releaseNotesManager.show(version, useCurrentFile);
 }
 async function openLatestReleaseNotesInBrowser(accessor) {
     const openerService = accessor.get(IOpenerService);
@@ -53,7 +53,7 @@ async function openLatestReleaseNotesInBrowser(accessor) {
 async function showReleaseNotes(accessor, version) {
     const instantiationService = accessor.get(IInstantiationService);
     try {
-        await showReleaseNotesInEditor(instantiationService, version);
+        await showReleaseNotesInEditor(instantiationService, version, false);
     }
     catch (err) {
         try {
@@ -102,7 +102,7 @@ let ProductContribution = class ProductContribution {
             const shouldShowReleaseNotes = configurationService.getValue('update.showReleaseNotes');
             const releaseNotesUrl = productService.releaseNotesUrl;
             if (shouldShowReleaseNotes && !environmentService.skipReleaseNotes && releaseNotesUrl && lastVersion && currentVersion && isMajorMinorUpdate(lastVersion, currentVersion)) {
-                showReleaseNotesInEditor(instantiationService, productService.version)
+                showReleaseNotesInEditor(instantiationService, productService.version, false)
                     .then(undefined, () => {
                     notificationService.prompt(Severity.Info, ( localizeWithPath(
                         'vs/workbench/contrib/update/browser/update',