@codingame/monaco-vscode-update-service-override 28.4.0 → 29.0.0

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

@@ -0,0 +1,429 @@
+
+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 { 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 * 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
+    ) {
+        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(14796, "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");
+        logoContainer.setAttribute("aria-label", this.productService.nameLong);
+        const details = append(this.productInfoNode, $(".product-details"));
+        this.productNameNode = append(details, $(".product-name"));
+        this.productNameNode.textContent = this.productService.nameLong;
+        const currentVersionRow = this.createVersionRow(details);
+        this.currentVersionNode = currentVersionRow.label;
+        this.currentVersionCopyValue = currentVersionRow.copyValue;
+        const latestVersionRow = this.createVersionRow(details);
+        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(14797, "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"));
+        const progressText = append(this.progressContainer, $(".progress-text"));
+        this.progressPercentNode = append(progressText, $("span"));
+        this.progressSizeNode = append(progressText, $("span"));
+        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.updateCurrentVersion();
+    }
+    updateCurrentVersion() {
+        const productVersion = this.productService.version;
+        if (productVersion) {
+            const currentCommitId = this.productService.commit?.substring(0, 7);
+            this.currentVersionNode.textContent = currentCommitId ? ( localize(14798, "Current Version: {0} ({1})", productVersion, currentCommitId)) : ( localize(14799, "Current Version: {0}", productVersion));
+            this.currentVersionCopyValue.value = currentCommitId ? `${productVersion} (${this.productService.commit})` : productVersion;
+            this.currentVersionNode.parentElement.style.display = "";
+        } else {
+            this.currentVersionNode.parentElement.style.display = "none";
+        }
+    }
+    hideAll() {
+        this.productInfoNode.style.display = "";
+        this.progressContainer.style.display = "none";
+        this.speedInfoNode.textContent = "";
+        this.timeRemainingNode.textContent = "";
+        this.messageNode.style.display = "none";
+        this.markdownContainer.style.display = "none";
+        this.markdown.clear();
+    }
+    renderState(state) {
+        this.hideAll();
+        switch (state.type) {
+        case StateType.Uninitialized:
+            this.renderUninitialized();
+            break;
+        case StateType.Disabled:
+            this.renderDisabled(state);
+            break;
+        case StateType.Idle:
+            this.renderIdle(state);
+            break;
+        case StateType.CheckingForUpdates:
+            this.renderCheckingForUpdates();
+            break;
+        case StateType.AvailableForDownload:
+            this.renderAvailableForDownload(state);
+            break;
+        case StateType.Downloading:
+            this.renderDownloading(state);
+            break;
+        case StateType.Downloaded:
+            this.renderDownloaded(state);
+            break;
+        case StateType.Updating:
+            this.renderUpdating(state);
+            break;
+        case StateType.Ready:
+            this.renderReady(state);
+            break;
+        case StateType.Overwriting:
+            this.renderOverwriting(state);
+            break;
+        }
+    }
+    renderUninitialized() {
+        this.renderTitleAndInfo(( localize(14800, "Initializing")));
+        this.renderMessage(( localize(14801, "Initializing update service...")));
+    }
+    renderDisabled(
+        {
+            reason
+        }
+    ) {
+        this.renderTitleAndInfo(( localize(14802, "Updates Disabled")));
+        switch (reason) {
+        case DisablementReason.NotBuilt:
+            this.renderMessage(( localize(14803, "Updates are not available for this build.")), Codicon.info);
+            break;
+        case DisablementReason.DisabledByEnvironment:
+            this.renderMessage(( localize(14804, "Updates are disabled by the --disable-updates command line flag.")), Codicon.warning);
+            break;
+        case DisablementReason.ManuallyDisabled:
+            this.renderMessage(( localize(
+                14805,
+                "Updates are manually disabled. Change the \"update.mode\" setting to enable."
+            )), Codicon.warning);
+            break;
+        case DisablementReason.Policy:
+            this.renderMessage(( localize(14806, "Updates are disabled by organization policy.")), Codicon.info);
+            break;
+        case DisablementReason.MissingConfiguration:
+            this.renderMessage(( localize(14807, "Updates are disabled because no update URL is configured.")), Codicon.info);
+            break;
+        case DisablementReason.InvalidConfiguration:
+            this.renderMessage(( localize(14808, "Updates are disabled because the update URL is invalid.")), Codicon.error);
+            break;
+        case DisablementReason.RunningAsAdmin:
+            this.renderMessage(( localize(
+                14809,
+                "Updates are not available when running a user install of {0} as administrator.",
+                this.productService.nameShort
+            )), Codicon.warning);
+            break;
+        default:
+            this.renderMessage(( localize(14810, "Updates are disabled.")), Codicon.warning);
+            break;
+        }
+    }
+    renderIdle(
+        {
+            error,
+            notAvailable
+        }
+    ) {
+        if (error) {
+            this.renderTitleAndInfo(( localize(14811, "Update Error")));
+            this.renderMessage(error, Codicon.error);
+            return;
+        }
+        if (notAvailable) {
+            this.renderTitleAndInfo(( localize(14812, "No Update Available")));
+            this.renderMessage(( localize(14813, "There are no updates currently available.")), Codicon.info);
+            return;
+        }
+        this.renderTitleAndInfo(( localize(14814, "Up to Date")));
+        switch (this.configurationService.getValue("update.mode")) {
+        case "none":
+            this.renderMessage(( localize(14815, "Automatic updates are disabled.")), Codicon.warning);
+            break;
+        case "manual":
+            this.renderMessage(( localize(
+                14816,
+                "Automatic updates will be checked but not installed automatically."
+            )));
+            break;
+        case "start":
+            this.renderMessage(( localize(14817, "Updates will be applied on restart.")));
+            break;
+        case "default":
+            if (this.meteredConnectionService.isConnectionMetered) {
+                this.renderMessage(( localize(
+                    14818,
+                    "Automatic updates are paused because the network connection is metered."
+                )), Codicon.radioTower);
+            } else {
+                this.renderMessage(( localize(14819, "Automatic updates are enabled. Happy Coding!")), Codicon.smiley);
+            }
+            break;
+        }
+    }
+    renderCheckingForUpdates() {
+        this.renderTitleAndInfo(( localize(14820, "Checking for Updates")));
+        this.renderMessage(( localize(14821, "Checking for updates, please wait...")));
+    }
+    renderAvailableForDownload(
+        {
+            update
+        }
+    ) {
+        this.renderTitleAndInfo(( localize(14822, "Update Available")), update);
+        if (this.hostedByTitleBar) {
+            this.renderMessage(( localize(14823, "Click the Update button to download.")));
+        }
+    }
+    renderDownloading(state) {
+        this.renderTitleAndInfo(( localize(14824, "Downloading Update")), state.update);
+        const {
+            downloadedBytes,
+            totalBytes
+        } = state;
+        if (downloadedBytes !== undefined && totalBytes !== undefined && totalBytes > 0) {
+            const percentage = computeProgressPercent(downloadedBytes, totalBytes) ?? 0;
+            this.progressFill.style.width = `${percentage}%`;
+            this.progressPercentNode.textContent = `${percentage}%`;
+            this.progressSizeNode.textContent = `${formatBytes(downloadedBytes)} / ${formatBytes(totalBytes)}`;
+            this.progressContainer.style.display = "";
+            const speed = computeDownloadSpeed(state);
+            if (speed !== undefined && speed > 0) {
+                this.speedInfoNode.textContent = ( localize(14825, "{0}/s", formatBytes(speed)));
+            }
+            const timeRemaining = computeDownloadTimeRemaining(state);
+            if (timeRemaining !== undefined && timeRemaining > 0) {
+                this.timeRemainingNode.textContent = `~${formatTimeRemaining(timeRemaining)} ${( localize(14826, "remaining"))}`;
+            }
+            this.downloadStatsContainer.style.display = "";
+        } else {
+            this.renderMessage(( localize(14827, "Downloading update, please wait...")));
+        }
+    }
+    renderDownloaded(
+        {
+            update
+        }
+    ) {
+        this.renderTitleAndInfo(( localize(14828, "Update is Ready to Install")), update);
+        if (this.hostedByTitleBar) {
+            this.renderMessage(( localize(14829, "Click the Update button to install.")));
+        }
+    }
+    renderUpdating(
+        {
+            update,
+            currentProgress,
+            maxProgress
+        }
+    ) {
+        this.renderTitleAndInfo(( localize(14830, "Installing Update")), update);
+        const percentage = computeProgressPercent(currentProgress, maxProgress);
+        if (percentage !== undefined) {
+            this.progressFill.style.width = `${percentage}%`;
+            this.progressPercentNode.textContent = `${percentage}%`;
+            this.progressSizeNode.textContent = "";
+            this.progressContainer.style.display = "";
+        } else {
+            this.renderMessage(( localize(14831, "Installing update, please wait...")));
+        }
+    }
+    renderReady(
+        {
+            update
+        }
+    ) {
+        this.renderTitleAndInfo(( localize(14832, "Update Installed")), update);
+        if (this.hostedByTitleBar) {
+            this.renderMessage(( localize(14833, "Click the Update button to restart and apply.")));
+        }
+    }
+    renderOverwriting(
+        {
+            update
+        }
+    ) {
+        this.renderTitleAndInfo(( localize(14834, "Downloading Newer Update")), update);
+        this.renderMessage(( localize(14835, "A newer update was released. Downloading, please wait...")));
+    }
+    async renderPostInstall() {
+        this.hideAll();
+        this.renderTitleAndInfo(( localize(14836, "New Update Installed")));
+        this.renderMessage(( localize(14837, "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;
+        }
+        this.titleNode.textContent = ( localize(14838, "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 = "";
+    }
+    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(14839, "Latest Version: {0} ({1})", version, updateCommitId)) : ( localize(14840, "Latest Version: {0}", version));
+            this.latestVersionCopyValue.value = updateCommitId ? `${version} (${update.version})` : version;
+            this.latestVersionNode.parentElement.style.display = "";
+        } else {
+            this.latestVersionNode.parentElement.style.display = "none";
+        }
+        const releaseDate = update?.timestamp ?? tryParseDate(this.productService.date);
+        if (typeof releaseDate === "number" && releaseDate > 0) {
+            this.releaseDateNode.textContent = ( localize(14841, "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";
+    }
+    renderMessage(message, icon) {
+        clearNode(this.messageNode);
+        if (icon) {
+            const iconNode = append(this.messageNode, $(".state-message-icon"));
+            iconNode.classList.add(...ThemeIcon.asClassNameArray(icon));
+        }
+        append(this.messageNode, createTextNode(message));
+        this.messageNode.style.display = "";
+    }
+    createVersionRow(parent) {
+        const row = append(parent, $(".product-version"));
+        const label = append(row, $("span"));
+        const copyValue = {
+            value: ""
+        };
+        const copyButton = append(row, $("a.copy-version-button"));
+        copyButton.setAttribute("role", "button");
+        copyButton.setAttribute("tabindex", "0");
+        const title = ( localize(14842, "Copy"));
+        copyButton.title = title;
+        copyButton.setAttribute("aria-label", title);
+        const copyIcon = append(copyButton, $(".copy-icon"));
+        copyIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.copy));
+        this._register(addDisposableListener(copyButton, "click", e => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (copyValue.value) {
+                this.clipboardService.writeText(copyValue.value);
+            }
+        }));
+        return {
+            label,
+            copyValue
+        };
+    }
+    runCommandAndClose(command, ...args) {
+        this.commandService.executeCommand(command, ...args);
+        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));
+
+export { UpdateTooltip };

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

@@ -0,0 +1,61 @@
+import { Downloading } from "@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update";
+/**
+ * Returns the progress percentage based on the current and maximum progress values.
+ */
+export declare function computeProgressPercent(current: number | undefined, max: number | undefined): number | undefined;
+/**
+ * Computes an estimate of remaining download time in seconds.
+ */
+export declare function computeDownloadTimeRemaining(state: Downloading): number | undefined;
+/**
+ * Computes the current download speed in bytes per second.
+ */
+export declare function computeDownloadSpeed(state: Downloading): number | undefined;
+/**
+ * Computes the version to use for fetching update info.
+ * - If the minor version differs: returns `{major}.{minor}` (e.g., 1.108.2 -> 1.109.5 => 1.109)
+ * - If the same minor: returns the target version as-is (e.g., 1.109.2 -> 1.109.5 => 1.109.5)
+ */
+export declare function computeUpdateInfoVersion(currentVersion: string, targetVersion: string): string | undefined;
+/**
+ * Computes the URL to fetch update info from.
+ * Follows the release notes URL pattern but with `_update` suffix.
+ */
+export declare function getUpdateInfoUrl(version: string): string;
+/**
+ * Formats the time remaining as a human-readable string.
+ */
+export declare function formatTimeRemaining(seconds: number): string;
+/**
+ * Formats a byte count as a human-readable string.
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Tries to parse a date string and returns the timestamp or undefined if parsing fails.
+ */
+export declare function tryParseDate(date: string | undefined): number | undefined;
+/**
+ * Formats a timestamp as a localized date string.
+ */
+export declare function formatDate(timestamp: number): string;
+/**
+ * Formats a number to 1 decimal place, omitting ".0" for whole numbers.
+ */
+export declare function formatDecimal(value: number): string;
+export interface IVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+/**
+ * Parses a version string in the format "major.minor.patch" and returns an object with the components.
+ */
+export declare function tryParseVersion(version: string | undefined): IVersion | undefined;
+/**
+ * Processes an error message and returns a user-friendly version of it, or undefined if the error should be ignored.
+ */
+export declare function preprocessError(error?: string): string | undefined;
+/**
+ * Determines whether there is a major or minor version change between two versions.
+ */
+export declare function isMajorMinorVersionChange(previousVersion?: string, newVersion?: string): boolean;

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

@@ -0,0 +1,141 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+function computeProgressPercent(current, max) {
+    if (current === undefined || max === undefined || max <= 0) {
+        return undefined;
+    }
+    return Math.max(Math.min(Math.round((current / max) * 100), 100), 0);
+}
+function computeDownloadTimeRemaining(state) {
+    const {
+        downloadedBytes,
+        totalBytes,
+        startTime
+    } = state;
+    if (downloadedBytes === undefined || totalBytes === undefined || startTime === undefined) {
+        return undefined;
+    }
+    const elapsedMs = Date.now() - startTime;
+    if (downloadedBytes <= 0 || totalBytes <= 0 || elapsedMs <= 0) {
+        return undefined;
+    }
+    const remainingBytes = totalBytes - downloadedBytes;
+    if (remainingBytes <= 0) {
+        return 0;
+    }
+    const bytesPerMs = downloadedBytes / elapsedMs;
+    if (bytesPerMs <= 0) {
+        return undefined;
+    }
+    const remainingMs = remainingBytes / bytesPerMs;
+    return Math.ceil(remainingMs / 1000);
+}
+function computeDownloadSpeed(state) {
+    const {
+        downloadedBytes,
+        startTime
+    } = state;
+    if (downloadedBytes === undefined || startTime === undefined) {
+        return undefined;
+    }
+    const elapsedMs = Date.now() - startTime;
+    if (elapsedMs <= 0 || downloadedBytes <= 0) {
+        return undefined;
+    }
+    return (downloadedBytes / elapsedMs) * 1000;
+}
+function getUpdateInfoUrl(version) {
+    const versionLabel = version.replace(/\./g, "_").replace(/_0$/, "");
+    return `https://code.visualstudio.com/raw/v${versionLabel}_update.md`;
+}
+function formatTimeRemaining(seconds) {
+    const hours = seconds / 3600;
+    if (hours >= 1) {
+        const formattedHours = formatDecimal(hours);
+        if (formattedHours === "1") {
+            return localize(14843, "{0} hour", formattedHours);
+        } else {
+            return localize(14844, "{0} hours", formattedHours);
+        }
+    }
+    const minutes = Math.floor(seconds / 60);
+    if (minutes >= 1) {
+        return localize(14845, "{0} min", minutes);
+    }
+    return localize(14846, "{0}s", seconds);
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return localize(14847, "{0} B", bytes);
+    }
+    const kb = bytes / 1024;
+    if (kb < 1024) {
+        return localize(14848, "{0} KB", formatDecimal(kb));
+    }
+    const mb = kb / 1024;
+    if (mb < 1024) {
+        return localize(14849, "{0} MB", formatDecimal(mb));
+    }
+    const gb = mb / 1024;
+    return localize(14850, "{0} GB", formatDecimal(gb));
+}
+function tryParseDate(date) {
+    if (date === undefined) {
+        return undefined;
+    }
+    try {
+        const parsed = Date.parse(date);
+        return isNaN(parsed) ? undefined : parsed;
+    } catch {
+        return undefined;
+    }
+}
+function formatDate(timestamp) {
+    return ( new Date(timestamp)).toLocaleDateString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric"
+    });
+}
+function formatDecimal(value) {
+    const rounded = Math.round(value * 10) / 10;
+    return rounded % 1 === 0 ? ( rounded.toString()) : rounded.toFixed(1);
+}
+function tryParseVersion(version) {
+    if (version === undefined) {
+        return undefined;
+    }
+    const match = /^(\d{1,10})\.(\d{1,10})\.(\d{1,10})/.exec(version);
+    if (!match) {
+        return undefined;
+    }
+    try {
+        return {
+            major: parseInt(match[1]),
+            minor: parseInt(match[2]),
+            patch: parseInt(match[3])
+        };
+    } catch {
+        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 };

package/vscode/src/vs/workbench/contrib/update/browser/media/releasenoteseditor.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.
- *--------------------------------------------------------------------------------------------*/
-
-.file-icons-enabled .show-file-icons .webview-vs_code_release_notes-name-file-icon.file-icon::before {
-	content: ' ';
-	background-image: var(--product-icon, url('../../../../browser/media/code-icon.svg'));
-}