@codingame/monaco-vscode-update-service-override 30.0.0 → 31.0.0

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

@@ -2,71 +2,41 @@
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { $, append, addDisposableListener, clearNode, createTextNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
-import { toAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { nativeHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover';
 import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
-import { openLinkFromMarkdown } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer';
-import { IMarkdownRendererService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service';
 import { IMeteredConnectionService } from '@codingame/monaco-vscode-api/vscode/vs/platform/meteredConnection/common/meteredConnection.service';
-import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
-import { asTextOrError } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
-import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
 import { StateType, DisablementReason } from '@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update';
-import { computeProgressPercent, formatBytes, computeDownloadSpeed, computeDownloadTimeRemaining, formatTimeRemaining, getUpdateInfoUrl, tryParseDate, formatDate } from '../common/updateUtils.js';
+import { ShowCurrentReleaseNotesActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/update/common/update';
+import { computeProgressPercent, formatBytes, computeDownloadSpeed, computeDownloadTimeRemaining, formatTimeRemaining, tryParseDate, formatDate } from '../common/updateUtils.js';
 import * as updateTooltip from './media/updateTooltip.css';
 
 registerCss(updateTooltip);
 let UpdateTooltip = class UpdateTooltip extends Disposable {
     constructor(
-        hostedByTitleBar,
         clipboardService,
         commandService,
         configurationService,
         hoverService,
-        markdownRendererService,
         meteredConnectionService,
-        openerService,
-        productService,
-        requestService
+        productService
     ) {
         super();
-        this.hostedByTitleBar = hostedByTitleBar;
         this.clipboardService = clipboardService;
         this.commandService = commandService;
         this.configurationService = configurationService;
         this.hoverService = hoverService;
-        this.markdownRendererService = markdownRendererService;
         this.meteredConnectionService = meteredConnectionService;
-        this.openerService = openerService;
         this.productService = productService;
-        this.requestService = requestService;
-        this.markdown = this._register(( new MutableDisposable()));
         this.domNode = $(".update-tooltip");
         const header = append(this.domNode, $(".header"));
         this.titleNode = append(header, $(".title"));
-        const actionBar = this._register(( new ActionBar(header, {
-            hoverDelegate: nativeHoverDelegate
-        })));
-        actionBar.push(toAction({
-            id: "update.openSettings",
-            label: ( localize(14878, "Update Settings")),
-            class: ThemeIcon.asClassName(Codicon.gear),
-            run: () => this.runCommandAndClose("workbench.action.openSettings", "@id:update*")
-        }), {
-            icon: true,
-            label: false
-        });
         this.productInfoNode = append(this.domNode, $(".product-info"));
         const logoContainer = append(this.productInfoNode, $(".product-logo"));
         logoContainer.setAttribute("role", "img");
@@ -81,15 +51,6 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         this.latestVersionNode = latestVersionRow.label;
         this.latestVersionCopyValue = latestVersionRow.copyValue;
         this.releaseDateNode = append(details, $(".product-release-date"));
-        this.releaseNotesLink = append(details, $("a.release-notes-link"));
-        this.releaseNotesLink.textContent = ( localize(14879, "Release Notes"));
-        this.releaseNotesLink.href = "#";
-        this._register(addDisposableListener(this.releaseNotesLink, "click", e => {
-            e.preventDefault();
-            if (this.releaseNotesVersion) {
-                this.runCommandAndClose("update.showCurrentReleaseNotes", this.releaseNotesVersion);
-            }
-        }));
         this.progressContainer = append(this.domNode, $(".progress-container"));
         const progressBar = append(this.progressContainer, $(".progress-bar"));
         this.progressFill = append(progressBar, $(".progress-fill"));
@@ -99,15 +60,29 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         this.downloadStatsContainer = append(this.progressContainer, $(".download-stats"));
         this.timeRemainingNode = append(this.downloadStatsContainer, $(".time-remaining"));
         this.speedInfoNode = append(this.downloadStatsContainer, $(".speed-info"));
-        this.markdownContainer = append(this.domNode, $(".update-markdown"));
         this.messageNode = append(this.domNode, $(".state-message"));
+        this.buttonBar = append(this.domNode, $(".button-bar"));
+        this.releaseNotesButton = append(this.buttonBar, $("button.release-notes-button"));
+        this.releaseNotesButton.textContent = ( localize(15015, "Release Notes"));
+        this._register(addDisposableListener(this.releaseNotesButton, "click", () => {
+            if (this.releaseNotesVersion) {
+                this.runCommandAndClose(ShowCurrentReleaseNotesActionId, this.releaseNotesVersion);
+            }
+        }));
+        this.actionButton = append(this.buttonBar, $("button.action-button"));
+        this._register(addDisposableListener(this.actionButton, "click", () => {
+            const commandId = this.actionButton.dataset.commandId;
+            if (commandId) {
+                this.runCommandAndClose(commandId);
+            }
+        }));
         this.updateCurrentVersion();
     }
     updateCurrentVersion() {
         const productVersion = this.productService.version;
         if (productVersion) {
             const currentCommitId = this.productService.commit?.substring(0, 7);
-            this.currentVersionNode.textContent = currentCommitId ? ( localize(14880, "Current Version: {0} ({1})", productVersion, currentCommitId)) : ( localize(14881, "Current Version: {0}", productVersion));
+            this.currentVersionNode.textContent = currentCommitId ? ( localize(15016, "Current Version: {0} ({1})", productVersion, currentCommitId)) : ( localize(15017, "Current Version: {0}", productVersion));
             this.currentVersionCopyValue.value = currentCommitId ? `${productVersion} (${this.productService.commit})` : productVersion;
             this.currentVersionNode.parentElement.style.display = "";
         } else {
@@ -120,8 +95,9 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         this.speedInfoNode.textContent = "";
         this.timeRemainingNode.textContent = "";
         this.messageNode.style.display = "none";
-        this.markdownContainer.style.display = "none";
-        this.markdown.clear();
+        this.actionButton.style.display = "none";
+        this.actionButton.dataset.commandId = "";
+        this.releaseNotesButton.style.marginRight = "";
     }
     renderState(state) {
         this.hideAll();
@@ -156,49 +132,52 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         case StateType.Overwriting:
             this.renderOverwriting(state);
             break;
+        case StateType.Restarting:
+            this.renderRestarting(state);
+            break;
         }
     }
     renderUninitialized() {
-        this.renderTitleAndInfo(( localize(14882, "Initializing")));
-        this.renderMessage(( localize(14883, "Initializing update service...")));
+        this.renderTitleAndInfo(( localize(15018, "Initializing")));
+        this.renderMessage(( localize(15019, "Initializing update service...")));
     }
     renderDisabled(
         {
             reason
         }
     ) {
-        this.renderTitleAndInfo(( localize(14884, "Updates Disabled")));
+        this.renderTitleAndInfo(( localize(15020, "Updates Disabled")));
         switch (reason) {
         case DisablementReason.NotBuilt:
-            this.renderMessage(( localize(14885, "Updates are not available for this build.")), Codicon.info);
+            this.renderMessage(( localize(15021, "Updates are not available for this build.")), Codicon.info);
             break;
         case DisablementReason.DisabledByEnvironment:
-            this.renderMessage(( localize(14886, "Updates are disabled by the --disable-updates command line flag.")), Codicon.warning);
+            this.renderMessage(( localize(15022, "Updates are disabled by the --disable-updates command line flag.")), Codicon.warning);
             break;
         case DisablementReason.ManuallyDisabled:
             this.renderMessage(( localize(
-                14887,
+                15023,
                 "Updates are manually disabled. Change the \"update.mode\" setting to enable."
             )), Codicon.warning);
             break;
         case DisablementReason.Policy:
-            this.renderMessage(( localize(14888, "Updates are disabled by organization policy.")), Codicon.info);
+            this.renderMessage(( localize(15024, "Updates are disabled by organization policy.")), Codicon.info);
             break;
         case DisablementReason.MissingConfiguration:
-            this.renderMessage(( localize(14889, "Updates are disabled because no update URL is configured.")), Codicon.info);
+            this.renderMessage(( localize(15025, "Updates are disabled because no update URL is configured.")), Codicon.info);
             break;
         case DisablementReason.InvalidConfiguration:
-            this.renderMessage(( localize(14890, "Updates are disabled because the update URL is invalid.")), Codicon.error);
+            this.renderMessage(( localize(15026, "Updates are disabled because the update URL is invalid.")), Codicon.error);
             break;
         case DisablementReason.RunningAsAdmin:
             this.renderMessage(( localize(
-                14891,
+                15027,
                 "Updates are not available when running a user install of {0} as administrator.",
                 this.productService.nameShort
             )), Codicon.warning);
             break;
         default:
-            this.renderMessage(( localize(14892, "Updates are disabled.")), Codicon.warning);
+            this.renderMessage(( localize(15028, "Updates are disabled.")), Codicon.warning);
             break;
         }
     }
@@ -209,57 +188,55 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         }
     ) {
         if (error) {
-            this.renderTitleAndInfo(( localize(14893, "Update Error")));
+            this.renderTitleAndInfo(( localize(15029, "Update Error")));
             this.renderMessage(error, Codicon.error);
             return;
         }
         if (notAvailable) {
-            this.renderTitleAndInfo(( localize(14894, "No Update Available")));
-            this.renderMessage(( localize(14895, "There are no updates currently available.")), Codicon.info);
+            this.renderTitleAndInfo(( localize(15030, "No Update Available")));
+            this.renderMessage(( localize(15031, "There are no updates currently available.")), Codicon.info);
             return;
         }
-        this.renderTitleAndInfo(( localize(14896, "Up to Date")));
+        this.renderTitleAndInfo(( localize(15032, "Up to Date")));
         switch (this.configurationService.getValue("update.mode")) {
         case "none":
-            this.renderMessage(( localize(14897, "Automatic updates are disabled.")), Codicon.warning);
+            this.renderMessage(( localize(15033, "Automatic updates are disabled.")), Codicon.warning);
             break;
         case "manual":
             this.renderMessage(( localize(
-                14898,
+                15034,
                 "Automatic updates will be checked but not installed automatically."
             )));
             break;
         case "start":
-            this.renderMessage(( localize(14899, "Updates will be applied on restart.")));
+            this.renderMessage(( localize(15035, "Updates will be applied on restart.")));
             break;
         case "default":
             if (this.meteredConnectionService.isConnectionMetered) {
                 this.renderMessage(( localize(
-                    14900,
+                    15036,
                     "Automatic updates are paused because the network connection is metered."
                 )), Codicon.radioTower);
             } else {
-                this.renderMessage(( localize(14901, "Automatic updates are enabled. Happy Coding!")), Codicon.smiley);
+                this.renderMessage(( localize(15037, "Automatic updates are enabled. Happy Coding!")), Codicon.smiley);
             }
             break;
         }
     }
     renderCheckingForUpdates() {
-        this.renderTitleAndInfo(( localize(14902, "Checking for Updates")));
-        this.renderMessage(( localize(14903, "Checking for updates, please wait...")));
+        this.renderTitleAndInfo(( localize(15038, "Checking for Updates")));
+        this.renderMessage(( localize(15039, "Checking for updates, please wait...")));
     }
     renderAvailableForDownload(
         {
             update
         }
     ) {
-        this.renderTitleAndInfo(( localize(14904, "Update Available")), update);
-        if (this.hostedByTitleBar) {
-            this.renderMessage(( localize(14905, "Click the Update button to download.")));
-        }
+        this.renderTitleAndInfo(( localize(15040, "Update Available")), update);
+        this.renderActionButton(( localize(15041, "Download")), "update.downloadNow");
     }
     renderDownloading(state) {
-        this.renderTitleAndInfo(( localize(14906, "Downloading Update")), state.update);
+        this.renderTitleAndInfo(( localize(15042, "Downloading Update")), state.update);
         const {
             downloadedBytes,
             totalBytes
@@ -272,15 +249,15 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
             this.progressContainer.style.display = "";
             const speed = computeDownloadSpeed(state);
             if (speed !== undefined && speed > 0) {
-                this.speedInfoNode.textContent = ( localize(14907, "{0}/s", formatBytes(speed)));
+                this.speedInfoNode.textContent = ( localize(15043, "{0}/s", formatBytes(speed)));
             }
             const timeRemaining = computeDownloadTimeRemaining(state);
             if (timeRemaining !== undefined && timeRemaining > 0) {
-                this.timeRemainingNode.textContent = `~${formatTimeRemaining(timeRemaining)} ${( localize(14908, "remaining"))}`;
+                this.timeRemainingNode.textContent = `~${formatTimeRemaining(timeRemaining)} ${( localize(15044, "remaining"))}`;
             }
             this.downloadStatsContainer.style.display = "";
         } else {
-            this.renderMessage(( localize(14909, "Downloading update, please wait...")));
+            this.renderMessage(( localize(15045, "Downloading update, please wait...")));
         }
     }
     renderDownloaded(
@@ -288,10 +265,8 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
             update
         }
     ) {
-        this.renderTitleAndInfo(( localize(14910, "Update is Ready to Install")), update);
-        if (this.hostedByTitleBar) {
-            this.renderMessage(( localize(14911, "Click the Update button to install.")));
-        }
+        this.renderTitleAndInfo(( localize(15046, "Update is Ready to Install")), update);
+        this.renderActionButton(( localize(15047, "Install")), "update.install");
     }
     renderUpdating(
         {
@@ -300,7 +275,7 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
             maxProgress
         }
     ) {
-        this.renderTitleAndInfo(( localize(14912, "Installing Update")), update);
+        this.renderTitleAndInfo(( localize(15048, "Installing Update")), update);
         const percentage = computeProgressPercent(currentProgress, maxProgress);
         if (percentage !== undefined) {
             this.progressFill.style.width = `${percentage}%`;
@@ -308,7 +283,7 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
             this.progressSizeNode.textContent = "";
             this.progressContainer.style.display = "";
         } else {
-            this.renderMessage(( localize(14913, "Installing update, please wait...")));
+            this.renderMessage(( localize(15049, "Installing update, please wait...")));
         }
     }
     renderReady(
@@ -316,9 +291,11 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
             update
         }
     ) {
-        this.renderTitleAndInfo(( localize(14914, "Update Installed")), update);
-        if (this.hostedByTitleBar) {
-            this.renderMessage(( localize(14915, "Click the Update button to restart and apply.")));
+        if (this.configurationService.getValue("update.mode") === "manual") {
+            this.renderTitleAndInfo(( localize(15050, "Update Installed")), update);
+            this.renderActionButton(( localize(15051, "Restart")), "update.restart");
+        } else {
+            this.renderTitleAndInfo(( localize(15052, "Restart to Update")), update);
         }
     }
     renderOverwriting(
@@ -326,49 +303,23 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
             update
         }
     ) {
-        this.renderTitleAndInfo(( localize(14916, "Downloading Newer Update")), update);
-        this.renderMessage(( localize(14917, "A newer update was released. Downloading, please wait...")));
+        this.renderTitleAndInfo(( localize(15053, "Downloading Newer Update")), update);
+        this.renderMessage(( localize(15054, "A newer update was released. Downloading, please wait...")));
     }
-    async renderPostInstall() {
-        this.hideAll();
-        this.renderTitleAndInfo(( localize(14918, "New Update Installed")));
-        this.renderMessage(( localize(14919, "See release notes for details on what's new in this release.")), Codicon.info);
-        let text = null;
-        try {
-            const url = getUpdateInfoUrl(this.productService.version);
-            const context = await this.requestService.request({
-                url,
-                callSite: "updateTooltip"
-            }, CancellationToken.None);
-            text = await asTextOrError(context);
-        } catch {}
-        if (!text) {
-            return;
+    renderRestarting(
+        {
+            update
         }
-        this.titleNode.textContent = ( localize(14920, "New in {0}", this.productService.version));
-        this.productInfoNode.style.display = "none";
-        this.messageNode.style.display = "none";
-        const rendered = this.markdownRendererService.render(( new MarkdownString(text, {
-            isTrusted: true,
-            supportHtml: true,
-            supportThemeIcons: true
-        })), {
-            actionHandler: (link, mdStr) => {
-                openLinkFromMarkdown(this.openerService, link, mdStr.isTrusted);
-                this.hoverService.hideHover(true);
-            }
-        });
-        this.markdown.value = rendered;
-        clearNode(this.markdownContainer);
-        this.markdownContainer.appendChild(rendered.element);
-        this.markdownContainer.style.display = "";
+    ) {
+        this.renderTitleAndInfo(( localize(15055, "Restarting {0}", this.productService.nameShort)), update);
+        this.renderMessage(( localize(15056, "Restarting to update, please wait...")));
     }
     renderTitleAndInfo(title, update) {
         this.titleNode.textContent = title;
         const version = update?.productVersion;
         if (version) {
             const updateCommitId = update.version?.substring(0, 7);
-            this.latestVersionNode.textContent = updateCommitId ? ( localize(14921, "Latest Version: {0} ({1})", version, updateCommitId)) : ( localize(14922, "Latest Version: {0}", version));
+            this.latestVersionNode.textContent = updateCommitId ? ( localize(15057, "Latest Version: {0} ({1})", version, updateCommitId)) : ( localize(15058, "Latest Version: {0}", version));
             this.latestVersionCopyValue.value = updateCommitId ? `${version} (${update.version})` : version;
             this.latestVersionNode.parentElement.style.display = "";
         } else {
@@ -376,13 +327,20 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         }
         const releaseDate = update?.timestamp ?? tryParseDate(this.productService.date);
         if (typeof releaseDate === "number" && releaseDate > 0) {
-            this.releaseDateNode.textContent = ( localize(14923, "Released {0}", formatDate(releaseDate)));
+            this.releaseDateNode.textContent = ( localize(15059, "Released {0}", formatDate(releaseDate)));
             this.releaseDateNode.style.display = "";
         } else {
             this.releaseDateNode.style.display = "none";
         }
         this.releaseNotesVersion = version ?? this.productService.version;
-        this.releaseNotesLink.style.display = this.releaseNotesVersion ? "" : "none";
+        this.releaseNotesButton.style.display = this.releaseNotesVersion ? "" : "none";
+        this.releaseNotesButton.style.marginRight = this.releaseNotesVersion ? "auto" : "";
+        this.buttonBar.style.display = this.releaseNotesVersion ? "" : "none";
+    }
+    renderActionButton(label, commandId) {
+        this.actionButton.textContent = label;
+        this.actionButton.dataset.commandId = commandId;
+        this.actionButton.style.display = "";
     }
     renderMessage(message, icon) {
         clearNode(this.messageNode);
@@ -402,7 +360,7 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         const copyButton = append(row, $("a.copy-version-button"));
         copyButton.setAttribute("role", "button");
         copyButton.setAttribute("tabindex", "0");
-        const title = ( localize(14924, "Copy"));
+        const title = ( localize(15060, "Copy"));
         copyButton.title = title;
         copyButton.setAttribute("aria-label", title);
         const copyIcon = append(copyButton, $(".copy-icon"));
@@ -424,6 +382,6 @@ let UpdateTooltip = class UpdateTooltip extends Disposable {
         this.hoverService.hideHover(true);
     }
 };
-UpdateTooltip = ( __decorate([( __param(1, IClipboardService)), ( __param(2, ICommandService)), ( __param(3, IConfigurationService)), ( __param(4, IHoverService)), ( __param(5, IMarkdownRendererService)), ( __param(6, IMeteredConnectionService)), ( __param(7, IOpenerService)), ( __param(8, IProductService)), ( __param(9, IRequestService))], UpdateTooltip));
+UpdateTooltip = ( __decorate([( __param(0, IClipboardService)), ( __param(1, ICommandService)), ( __param(2, IConfigurationService)), ( __param(3, IHoverService)), ( __param(4, IMeteredConnectionService)), ( __param(5, IProductService))], UpdateTooltip));
 
 export { UpdateTooltip };

package/vscode/src/vs/workbench/contrib/update/common/updateInfoParser.d.ts

@@ -0,0 +1,42 @@
+export type UpdateInfoButtonStyle = "primary" | "secondary";
+export interface IUpdateInfoButton {
+    readonly label: string;
+    readonly commandId: string;
+    readonly args?: unknown[];
+    readonly style?: UpdateInfoButtonStyle;
+}
+export interface IParsedUpdateInfoInput {
+    readonly markdown: string;
+    readonly buttons?: IUpdateInfoButton[];
+}
+/**
+ * Parses optional metadata from update info input.
+ *
+ * Supported formats:
+ *
+ * **JSON envelope** - a single JSON object with `markdown` and optional `buttons`:
+ * ```json
+ * {
+ *   "markdown": "$(info) **Feature**<br>Description...",
+ *   "buttons": [
+ *     { "label": "Release Notes", "commandId": "update.showCurrentReleaseNotes", "style": "secondary" },
+ *     { "label": "Open Sessions", "commandId": "workbench.action.chat.open", "style": "primary" }
+ *   ]
+ * }
+ * ```
+ *
+ * **Block frontmatter** - YAML-style `---` delimiters wrapping a JSON metadata block:
+ * ```
+ * ---
+ * { "buttons": [...] }
+ * ---
+ * $(info) **Feature**<br>Description...
+ * ```
+ *
+ * **Inline frontmatter** - metadata on a single `---` line:
+ * ```
+ * --- { "buttons": [...] } ---
+ * $(info) **Feature**<br>Description...
+ * ```
+ */
+export declare function parseUpdateInfoInput(text: string): IParsedUpdateInfoInput;

package/vscode/src/vs/workbench/contrib/update/common/updateInfoParser.js

@@ -0,0 +1,74 @@
+
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+function parseUpdateInfoInput(text) {
+    const normalized = text.replace(/^\uFEFF/, '');
+    return tryParseUpdateInfoEnvelope(normalized) ?? parseUpdateInfoFrontmatter(normalized);
+}
+function tryParseUpdateInfoEnvelope(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+        return undefined;
+    }
+    try {
+        const value = JSON.parse(trimmed);
+        if (typeof value.markdown !== 'string') {
+            return undefined;
+        }
+        return {
+            markdown: value.markdown,
+            buttons: parseUpdateInfoButtons(value.buttons),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseUpdateInfoFrontmatter(text) {
+    const blockMatch = text.match(/^---[ \t]*\r?\n(?<json>[\s\S]*?)\r?\n---[ \t]*(?:\r?\n(?<body>[\s\S]*))?$/);
+    if (blockMatch?.groups) {
+        return parseUpdateInfoFrontmatterMatch(text, blockMatch.groups['json'], blockMatch.groups['body'] ?? '');
+    }
+    const inlineMatch = text.match(/^---[ \t]*(?<json>\{.*\})[ \t]*---[ \t]*(?<body>[\s\S]*)$/);
+    if (inlineMatch?.groups) {
+        return parseUpdateInfoFrontmatterMatch(text, inlineMatch.groups['json'], inlineMatch.groups['body']);
+    }
+    return { markdown: text };
+}
+function parseUpdateInfoFrontmatterMatch(text, jsonText, markdown) {
+    try {
+        const meta = JSON.parse(jsonText);
+        return {
+            markdown,
+            buttons: parseUpdateInfoButtons(meta.buttons),
+        };
+    }
+    catch {
+        return { markdown: text };
+    }
+}
+function parseUpdateInfoButtons(buttons) {
+    if (!Array.isArray(buttons)) {
+        return undefined;
+    }
+    const parsedButtons = [];
+    for (const button of buttons) {
+        if (typeof button !== 'object' || button === null) {
+            continue;
+        }
+        if (!hasKey(button, { label: true, commandId: true }) || typeof button.label !== 'string' || typeof button.commandId !== 'string') {
+            continue;
+        }
+        const style = hasKey(button, { style: true }) && (button.style === 'primary' || button.style === 'secondary') ? button.style : undefined;
+        const args = hasKey(button, { args: true }) && Array.isArray(button.args) ? button.args : undefined;
+        parsedButtons.push({
+            label: button.label,
+            commandId: button.commandId,
+            args,
+            style,
+        });
+    }
+    return parsedButtons.length ? parsedButtons : undefined;
+}
+
+export { parseUpdateInfoInput };

package/vscode/src/vs/workbench/contrib/update/common/updateUtils.js

@@ -54,31 +54,31 @@ function formatTimeRemaining(seconds) {
     if (hours >= 1) {
         const formattedHours = formatDecimal(hours);
         if (formattedHours === "1") {
-            return localize(14925, "{0} hour", formattedHours);
+            return localize(15061, "{0} hour", formattedHours);
         } else {
-            return localize(14926, "{0} hours", formattedHours);
+            return localize(15062, "{0} hours", formattedHours);
         }
     }
     const minutes = Math.floor(seconds / 60);
     if (minutes >= 1) {
-        return localize(14927, "{0} min", minutes);
+        return localize(15063, "{0} min", minutes);
     }
-    return localize(14928, "{0}s", seconds);
+    return localize(15064, "{0}s", seconds);
 }
 function formatBytes(bytes) {
     if (bytes < 1024) {
-        return localize(14929, "{0} B", bytes);
+        return localize(15065, "{0} B", bytes);
     }
     const kb = bytes / 1024;
     if (kb < 1024) {
-        return localize(14930, "{0} KB", formatDecimal(kb));
+        return localize(15066, "{0} KB", formatDecimal(kb));
     }
     const mb = kb / 1024;
     if (mb < 1024) {
-        return localize(14931, "{0} MB", formatDecimal(mb));
+        return localize(15067, "{0} MB", formatDecimal(mb));
     }
     const gb = mb / 1024;
-    return localize(14932, "{0} GB", formatDecimal(gb));
+    return localize(15068, "{0} GB", formatDecimal(gb));
 }
 function tryParseDate(date) {
     if (date === undefined) {
@@ -120,22 +120,10 @@ function tryParseVersion(version) {
         return undefined;
     }
 }
-function preprocessError(error) {
-    if (!error) {
-        return undefined;
-    }
-    if (/The request timed out|The network connection was lost/i.test(error)) {
-        return undefined;
-    }
-    return error.replace(
-        /See https:\/\/github\.com\/Squirrel\/Squirrel\.Mac\/issues\/182 for more information/,
-        "This might mean the application was put on quarantine by macOS. See [this link](https://github.com/microsoft/vscode/issues/7426#issuecomment-425093469) for more information"
-    );
-}
 function isMajorMinorVersionChange(previousVersion, newVersion) {
     const previous = tryParseVersion(previousVersion);
     const current = tryParseVersion(newVersion);
     return !!previous && !!current && (previous.major !== current.major || previous.minor !== current.minor);
 }
 
-export { computeDownloadSpeed, computeDownloadTimeRemaining, computeProgressPercent, formatBytes, formatDate, formatDecimal, formatTimeRemaining, getUpdateInfoUrl, isMajorMinorVersionChange, preprocessError, tryParseDate, tryParseVersion };
+export { computeDownloadSpeed, computeDownloadTimeRemaining, computeProgressPercent, formatBytes, formatDate, formatDecimal, formatTimeRemaining, getUpdateInfoUrl, isMajorMinorVersionChange, tryParseDate, tryParseVersion };

package/vscode/src/vs/workbench/contrib/update/browser/media/updateStatusBarEntry.css

@@ -1,9 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-.monaco-workbench .part.statusbar > .items-container > #status\.update > a > span {
-	color: var(--vscode-button-background);
-	font-size: 16px;
-}

package/vscode/src/vs/workbench/contrib/update/browser/updateStatusBarEntry.d.ts

@@ -1,22 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { IUpdateService } from "@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update.service";
-import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-import { IStatusbarService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar.service";
-/**
- * Displays update status and actions in the status bar.
- */
-export declare class UpdateStatusBarContribution extends Disposable implements IWorkbenchContribution {
-    private readonly configurationService;
-    private readonly statusbarService;
-    private static readonly actionableStates;
-    private readonly accessor;
-    private readonly tooltip;
-    private lastStateType;
-    constructor(configurationService: IConfigurationService, instantiationService: IInstantiationService, statusbarService: IStatusbarService, updateService: IUpdateService);
-    private onStateChange;
-    private updateEntry;
-    private getDownloadingText;
-    private getUpdatingText;
-}