@codingame/monaco-vscode-update-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,413 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/releasenoteseditor.css.js';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
+import { escapeMarkdownSyntaxTokens } from 'vscode/vscode/vs/base/common/htmlContent';
+import { KeybindingParser } from 'vscode/vscode/vs/base/common/keybindingParser';
+import { escape } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { TokenizationRegistry } from 'vscode/vscode/vs/editor/common/languages';
+import { generateTokensCSSForColorMap } from 'vscode/vscode/vs/editor/common/languages/supports/tokenization';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
+import { IRequestService, asTextOrError } from 'vscode/vscode/vs/platform/request/common/request';
+import { renderMarkdownDocument, DEFAULT_MARKDOWN_STYLES } from 'vscode/vscode/vs/workbench/contrib/markdown/browser/markdownDocumentRenderer';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+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, _codeEditorService, _webviewWorkbenchService, _extensionService, _productService, _instantiationService) {
+        this._environmentService = _environmentService;
+        this._keybindingService = _keybindingService;
+        this._languageService = _languageService;
+        this._openerService = _openerService;
+        this._requestService = _requestService;
+        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(() => {
+            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 html = await this.renderBody(this._lastText);
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.webview.setHtml(html);
+        }
+    }
+    async show(version, useCurrentFile) {
+        const releaseNoteText = await this.loadReleaseNotes(version, useCurrentFile);
+        this._lastText = releaseNoteText;
+        const html = await this.renderBody(releaseNoteText);
+        const title = ( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'releaseNotesInputName',
+            "Release Notes: {0}",
+            version
+        ));
+        const activeEditorPane = this._editorService.activeEditorPane;
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.setName(title);
+            this._currentReleaseNotes.webview.setHtml(html);
+            this._webviewWorkbenchService.revealWebview(this._currentReleaseNotes, activeEditorPane ? activeEditorPane.group : this._editorGroupService.activeGroup, false);
+        }
+        else {
+            this._currentReleaseNotes = this._webviewWorkbenchService.openWebview({
+                title,
+                options: {
+                    tryRestoreScrollPosition: true,
+                    enableFindWidget: true,
+                    disableServiceWorker: true,
+                },
+                contentOptions: {
+                    localResourceRoots: [],
+                    allowScripts: true
+                },
+                extension: undefined
+            }, 'releaseNotes', title, { group: ACTIVE_GROUP, preserveFocus: false });
+            this._currentReleaseNotes.webview.onDidClickLink(uri => this.onDidClickLink(( URI.parse(uri))));
+            const disposables = ( new DisposableStore());
+            disposables.add(this._currentReleaseNotes.webview.onMessage(e => {
+                if (e.message.type === 'showReleaseNotes') {
+                    this._configurationService.updateValue('update.showReleaseNotes', e.message.value);
+                }
+                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();
+                this._currentReleaseNotes = undefined;
+            }));
+            this._currentReleaseNotes.webview.setHtml(html);
+        }
+        return true;
+    }
+    async loadReleaseNotes(version, useCurrentFile) {
+        const match = /^(\d+\.\d+)\./.exec(version);
+        if (!match) {
+            throw new Error('not found');
+        }
+        const versionLabel = match[1].replace(/\./g, '_');
+        const baseUrl = 'https://code.visualstudio.com/raw';
+        const url = `${baseUrl}/v${versionLabel}.md`;
+        const unassigned = ( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'unassigned',
+            "unassigned"
+        ));
+        const escapeMdHtml = (text) => {
+            return escape(text).replace(/\\/g, '\\\\');
+        };
+        const patchKeybindings = (text) => {
+            const kb = (match, kb) => {
+                const keybinding = this._keybindingService.lookupKeybinding(kb);
+                if (!keybinding) {
+                    return unassigned;
+                }
+                return keybinding.getLabel() || unassigned;
+            };
+            const kbstyle = (match, kb) => {
+                const keybinding = KeybindingParser.parseKeybinding(kb);
+                if (!keybinding) {
+                    return unassigned;
+                }
+                const resolvedKeybindings = this._keybindingService.resolveKeybinding(keybinding);
+                if (resolvedKeybindings.length === 0) {
+                    return unassigned;
+                }
+                return resolvedKeybindings[0].getLabel() || unassigned;
+            };
+            const kbCode = (match, binding) => {
+                const resolved = kb(match, binding);
+                return resolved ? `<code title="${binding}">${escapeMdHtml(resolved)}</code>` : resolved;
+            };
+            const kbstyleCode = (match, binding) => {
+                const resolved = kbstyle(match, binding);
+                return resolved ? `<code title="${binding}">${escapeMdHtml(resolved)}</code>` : resolved;
+            };
+            return text
+                .replace(/`kb\(([a-z.\d\-]+)\)`/gi, kbCode)
+                .replace(/`kbstyle\(([^\)]+)\)`/gi, kbstyleCode)
+                .replace(/kb\(([a-z.\d\-]+)\)/gi, (match, binding) => escapeMarkdownSyntaxTokens(kb(match, binding)))
+                .replace(/kbstyle\(([^\)]+)\)/gi, (match, binding) => escapeMarkdownSyntaxTokens(kbstyle(match, binding)));
+        };
+        const fetchReleaseNotes = async () => {
+            let text;
+            try {
+                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');
+            }
+            if (!text || !/^#\s/.test(text)) {
+                throw new Error('Invalid release notes');
+            }
+            return patchKeybindings(text);
+        };
+        if (useCurrentFile) {
+            return fetchReleaseNotes();
+        }
+        if (!( this._releaseNotesCache.has(version))) {
+            this._releaseNotesCache.set(version, (async () => {
+                try {
+                    return await fetchReleaseNotes();
+                }
+                catch (err) {
+                    this._releaseNotesCache.delete(version);
+                    throw err;
+                }
+            })());
+        }
+        return this._releaseNotesCache.get(version);
+    }
+    async onDidClickLink(uri) {
+        if (uri.scheme === Schemas.codeSetting) ;
+        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 ) {
+            if (uri.scheme === 'https' && uri.authority === 'code.visualstudio.com') {
+                return uri.with({ query: `${uri.query ? uri.query + '&' : ''}utm_source=VsCode&utm_medium=${encodeURIComponent(origin)}&utm_content=${encodeURIComponent(experiment)}` });
+            }
+        }
+        return uri;
+    }
+    async renderBody(text) {
+        const nonce = generateUuid();
+        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'));
+        return `<!DOCTYPE html>
+		<html>
+			<head>
+				<base href="https://code.visualstudio.com/raw/">
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src https: data:; media-src https:; style-src 'nonce-${nonce}' https://code.visualstudio.com; script-src 'nonce-${nonce}';">
+				<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;
+					}
+
+					header { display: flex; align-items: center; padding-top: 1em; }
+				</style>
+			</head>
+			<body>
+				${content}
+				<script nonce="${nonce}">
+					const vscode = acquireVsCodeApi();
+					const container = document.createElement('p');
+					container.style.display = 'flex';
+					container.style.alignItems = 'center';
+
+					const input = document.createElement('input');
+					input.type = 'checkbox';
+					input.id = 'showReleaseNotes';
+					input.checked = ${showReleaseNotes};
+					container.appendChild(input);
+
+					const label = document.createElement('label');
+					label.htmlFor = 'showReleaseNotes';
+					label.textContent = '${( localizeWithPath(
+            'vs/workbench/contrib/update/browser/releaseNotesEditor',
+            'showOnUpdate',
+            "Show release notes after an update"
+        ))}';
+					container.appendChild(label);
+
+					const beforeElement = document.querySelector("body > h1")?.nextElementSibling;
+					if (beforeElement) {
+						document.body.insertBefore(container, beforeElement);
+					} else {
+						document.body.appendChild(container);
+					}
+
+					window.addEventListener('message', event => {
+						if (event.data.type === 'showReleaseNotes') {
+							input.checked = event.data.value;
+						}
+					});
+
+					window.addEventListener('click', event => {
+						const href = event.target.href ?? event.target.parentElement.href ?? event.target.parentElement.parentElement?.href;
+						if (href && (href.startsWith('${Schemas.codeSetting}'))) {
+							vscode.postMessage({ type: 'clickSetting', value: { uri: href, x: event.clientX, y: event.clientY }});
+						}
+					});
+
+					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 }});
+							}
+						}
+					});
+
+					input.addEventListener('change', event => {
+						vscode.postMessage({ type: 'showReleaseNotes', value: input.checked }, '*');
+					});
+				</script>
+			</body>
+		</html>`;
+    }
+    onDidChangeConfiguration(e) {
+        if (e.affectsConfiguration('update.showReleaseNotes')) {
+            this.updateCheckboxWebview();
+        }
+    }
+    onDidChangeActiveWebviewEditor(input) {
+        if (input && input === this._currentReleaseNotes) {
+            this.updateCheckboxWebview();
+        }
+    }
+    updateCheckboxWebview() {
+        if (this._currentReleaseNotes) {
+            this._currentReleaseNotes.webview.postMessage({
+                type: 'showReleaseNotes',
+                value: this._configurationService.getValue('update.showReleaseNotes')
+            });
+        }
+    }
+};
+ReleaseNotesManager = ( __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IKeybindingService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IOpenerService)),
+    ( __param(4, IRequestService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __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

@@ -0,0 +1,254 @@
+import '../../../../platform/update/common/update.config.contribution.js';
+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';
+import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ProductContribution, UpdateContribution, SwitchProductQualityContribution, DOWNLOAD_URL, RELEASE_NOTES_URL, showReleaseNotesInEditor, CONTEXT_UPDATE_STATE } from './update.js';
+import product$1 from 'vscode/vscode/vs/platform/product/common/product';
+import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+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, 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';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const workbench = ( Registry.as(Extensions.Workbench));
+workbench.registerWorkbenchContribution(ProductContribution, 3 );
+workbench.registerWorkbenchContribution(UpdateContribution, 3 );
+workbench.registerWorkbenchContribution(SwitchProductQualityContribution, 3 );
+class ShowCurrentReleaseNotesAction extends Action2 {
+    constructor() {
+        super({
+            id: ShowCurrentReleaseNotesActionId,
+            title: {
+                ...( localize2WithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    'showReleaseNotes',
+                    "Show Release Notes"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    { key: 'mshowReleaseNotes', comment: ['&& denotes a mnemonic'] },
+                    "Show &&Release Notes"
+                )),
+            },
+            category: { value: product$1.nameShort, original: product$1.nameShort },
+            f1: true,
+            precondition: RELEASE_NOTES_URL,
+            menu: [{
+                    id: MenuId.MenubarHelpMenu,
+                    group: '1_welcome',
+                    order: 5,
+                    when: RELEASE_NOTES_URL,
+                }]
+        });
+    }
+    async run(accessor) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const productService = accessor.get(IProductService);
+        const openerService = accessor.get(IOpenerService);
+        try {
+            await showReleaseNotesInEditor(instantiationService, productService.version, false);
+        }
+        catch (err) {
+            if (productService.releaseNotesUrl) {
+                await openerService.open(( URI.parse(productService.releaseNotesUrl)));
+            }
+            else {
+                throw new Error(localizeWithPath('vs/workbench/contrib/update/browser/update.contribution', 'update.noReleaseNotesOnline', "This version of {0} does not have release notes online", productService.nameLong));
+            }
+        }
+    }
+}
+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({
+            id: 'update.checkForUpdate',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'checkForUpdates',
+                'Check for Updates...'
+            )),
+            category: { value: product$1.nameShort, original: product$1.nameShort },
+            f1: true,
+            precondition: ( CONTEXT_UPDATE_STATE.isEqualTo("idle" )),
+        });
+    }
+    async run(accessor) {
+        const updateService = accessor.get(IUpdateService);
+        return updateService.checkForUpdates(true);
+    }
+}
+class DownloadUpdateAction extends Action2 {
+    constructor() {
+        super({
+            id: 'update.downloadUpdate',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'downloadUpdate',
+                'Download Update'
+            )),
+            category: { value: product$1.nameShort, original: product$1.nameShort },
+            f1: true,
+            precondition: ( CONTEXT_UPDATE_STATE.isEqualTo("available for download" ))
+        });
+    }
+    async run(accessor) {
+        await accessor.get(IUpdateService).downloadUpdate();
+    }
+}
+class InstallUpdateAction extends Action2 {
+    constructor() {
+        super({
+            id: 'update.installUpdate',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'installUpdate',
+                'Install Update'
+            )),
+            category: { value: product$1.nameShort, original: product$1.nameShort },
+            f1: true,
+            precondition: ( CONTEXT_UPDATE_STATE.isEqualTo("downloaded" ))
+        });
+    }
+    async run(accessor) {
+        await accessor.get(IUpdateService).applyUpdate();
+    }
+}
+class RestartToUpdateAction extends Action2 {
+    constructor() {
+        super({
+            id: 'update.restartToUpdate',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'restartToUpdate',
+                'Restart to Update'
+            )),
+            category: { value: product$1.nameShort, original: product$1.nameShort },
+            f1: true,
+            precondition: ( CONTEXT_UPDATE_STATE.isEqualTo("ready" ))
+        });
+    }
+    async run(accessor) {
+        await accessor.get(IUpdateService).quitAndInstall();
+    }
+}
+class DownloadAction extends Action2 {
+    static { this.ID = 'workbench.action.download'; }
+    constructor() {
+        super({
+            id: DownloadAction.ID,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/update/browser/update.contribution',
+                'openDownloadPage',
+                "Download {0}",
+                product$1.nameLong
+            )),
+            precondition: ( ContextKeyExpr.and(IsWebContext, DOWNLOAD_URL)),
+            f1: true,
+            menu: [{
+                    id: MenuId.StatusBarWindowIndicatorMenu,
+                    when: ( ContextKeyExpr.and(IsWebContext, DOWNLOAD_URL))
+                }]
+        });
+    }
+    run(accessor) {
+        const productService = accessor.get(IProductService);
+        const openerService = accessor.get(IOpenerService);
+        if (productService.downloadUrl) {
+            openerService.open(( URI.parse(productService.downloadUrl)));
+        }
+    }
+}
+registerAction2(DownloadAction);
+registerAction2(CheckForUpdateAction);
+registerAction2(DownloadUpdateAction);
+registerAction2(InstallUpdateAction);
+registerAction2(RestartToUpdateAction);
+if (isWindows) {
+    class DeveloperApplyUpdateAction extends Action2 {
+        constructor() {
+            super({
+                id: '_update.applyupdate',
+                title: ( localize2WithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    'applyUpdate',
+                    'Apply Update...'
+                )),
+                category: Categories.Developer,
+                f1: true,
+                precondition: ( CONTEXT_UPDATE_STATE.isEqualTo("idle" ))
+            });
+        }
+        async run(accessor) {
+            const updateService = accessor.get(IUpdateService);
+            const fileDialogService = accessor.get(IFileDialogService);
+            const updatePath = await fileDialogService.showOpenDialog({
+                title: ( localizeWithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    'pickUpdate',
+                    "Apply Update"
+                )),
+                filters: [{ name: 'Setup', extensions: ['exe'] }],
+                canSelectFiles: true,
+                openLabel: mnemonicButtonLabel(( localizeWithPath(
+                    'vs/workbench/contrib/update/browser/update.contribution',
+                    { key: 'updateButton', comment: ['&& denotes a mnemonic'] },
+                    "&&Update"
+                )))
+            });
+            if (!updatePath || !updatePath[0]) {
+                return;
+            }
+            await updateService._applySpecificUpdate(updatePath[0].fsPath);
+        }
+    }
+    registerAction2(DeveloperApplyUpdateAction);
+}
+
+export { CheckForUpdateAction, ShowCurrentReleaseNotesAction, ShowCurrentReleaseNotesFromCurrentFileAction };