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

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

@@ -0,0 +1,319 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, scheduleAtNextAnimationFrame, getWindow, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+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 { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { StateType, DisablementReason } from '@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update';
+import { IUpdateService } from '@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { isMajorMinorVersionChange, computeProgressPercent } from '../common/updateUtils.js';
+import * as updateTitleBarEntry from './media/updateTitleBarEntry.css';
+import { UpdateTooltip } from './updateTooltip.js';
+
+registerCss(updateTitleBarEntry);
+const UPDATE_TITLE_BAR_ACTION_ID = "workbench.actions.updateIndicator";
+const UPDATE_TITLE_BAR_CONTEXT = ( new RawContextKey("updateTitleBar", false));
+const ACTIONABLE_STATES = [StateType.AvailableForDownload, StateType.Downloaded, StateType.Ready];
+const DETAILED_STATES = [
+    ...ACTIONABLE_STATES,
+    StateType.CheckingForUpdates,
+    StateType.Downloading,
+    StateType.Updating,
+    StateType.Overwriting
+];
+const LAST_KNOWN_VERSION_KEY = "updateTitleBarEntry/lastKnownVersion";
+registerAction2(class UpdateIndicatorTitleBarAction extends Action2 {
+    constructor() {
+        super({
+            id: UPDATE_TITLE_BAR_ACTION_ID,
+            title: ( localize(14794, "Update")),
+            f1: false,
+            menu: [{
+                id: MenuId.TitleBarAdjacentCenter,
+                order: 0,
+                when: UPDATE_TITLE_BAR_CONTEXT
+            }]
+        });
+    }
+    async run() {}
+});
+let UpdateTitleBarContribution = class UpdateTitleBarContribution extends Disposable {
+    constructor(
+        actionViewItemService,
+        configurationService,
+        contextKeyService,
+        hostService,
+        instantiationService,
+        productService,
+        storageService,
+        telemetryService,
+        updateService
+    ) {
+        super();
+        this.configurationService = configurationService;
+        this.hostService = hostService;
+        this.productService = productService;
+        this.storageService = storageService;
+        this.telemetryService = telemetryService;
+        this.mode = "none";
+        this.tooltipVisible = false;
+        if (isWeb) {
+            return;
+        }
+        this.context = UPDATE_TITLE_BAR_CONTEXT.bindTo(contextKeyService);
+        this.tooltip = this._register(instantiationService.createInstance(UpdateTooltip, true));
+        this.mode = configurationService.getValue("update.titleBar");
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("update.titleBar")) {
+                this.mode = configurationService.getValue("update.titleBar");
+                this.onStateChange();
+            }
+        }));
+        this.state = updateService.state;
+        this._register(updateService.onStateChange(state => {
+            this.state = state;
+            this.onStateChange();
+        }));
+        this._register(actionViewItemService.register(
+            MenuId.TitleBarAdjacentCenter,
+            UPDATE_TITLE_BAR_ACTION_ID,
+            (action, options) => {
+                this.entry = instantiationService.createInstance(UpdateTitleBarEntry, action, options, this.tooltip, () => {
+                    this.tooltipVisible = false;
+                    this.updateContext();
+                });
+                if (this.tooltipVisible) {
+                    this.entry.showTooltip();
+                }
+                return this.entry;
+            }
+        ));
+        void this.onStateChange(true);
+    }
+    updateContext() {
+        switch (this.mode) {
+        case "always":
+            this.context.set(true);
+            break;
+        case "detailed":
+            this.context.set(DETAILED_STATES.includes(this.state.type));
+            break;
+        case "actionable":
+            this.context.set(ACTIONABLE_STATES.includes(this.state.type));
+            break;
+        default:
+            this.context.set(false);
+            break;
+        }
+    }
+    async onStateChange(startup = false) {
+        this.updateContext();
+        if (this.mode === "none" || this.tooltipVisible || !(await this.hostService.hadLastFocus())) {
+            return;
+        }
+        let showTooltip = startup && this.detectVersionChange();
+        if (showTooltip) {
+            this.tooltip.renderPostInstall();
+        } else {
+            this.tooltip.renderState(this.state);
+            switch (this.state.type) {
+            case StateType.Disabled:
+                if (startup) {
+                    const reason = this.state.reason;
+                    showTooltip = reason === DisablementReason.InvalidConfiguration || reason === DisablementReason.RunningAsAdmin;
+                }
+                break;
+            case StateType.Idle:
+                showTooltip = !!this.state.error || !!this.state.notAvailable;
+                break;
+            }
+        }
+        if (showTooltip) {
+            this.tooltipVisible = true;
+            this.context.set(true);
+            this.entry?.showTooltip();
+        }
+    }
+    detectVersionChange() {
+        let from;
+        try {
+            from = this.storageService.getObject(LAST_KNOWN_VERSION_KEY, StorageScope.APPLICATION);
+        } catch {}
+        const to = {
+            version: this.productService.version,
+            commit: this.productService.commit,
+            timestamp: Date.now()
+        };
+        if (from?.commit === to.commit) {
+            return false;
+        }
+        this.storageService.store(
+            LAST_KNOWN_VERSION_KEY,
+            JSON.stringify(to),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+        if (from) {
+            this.trackVersionChange(from, to);
+            return isMajorMinorVersionChange(from.version, to.version);
+        }
+        return false;
+    }
+    trackVersionChange(from, to) {
+        this.telemetryService.publicLog2("update:versionChanged", {
+            fromVersion: from.version,
+            fromCommit: from.commit,
+            fromVersionTime: from.timestamp,
+            toVersion: to.version,
+            toCommit: to.commit,
+            timeToUpdateMs: from.timestamp !== undefined ? to.timestamp - from.timestamp : undefined,
+            updateMode: this.configurationService.getValue("update.mode"),
+            titleBarMode: this.mode
+        });
+    }
+};
+UpdateTitleBarContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, IConfigurationService)), ( __param(2, IContextKeyService)), ( __param(3, IHostService)), ( __param(4, IInstantiationService)), ( __param(5, IProductService)), ( __param(6, IStorageService)), ( __param(7, ITelemetryService)), ( __param(8, IUpdateService))], UpdateTitleBarContribution));
+let UpdateTitleBarEntry = class UpdateTitleBarEntry extends BaseActionViewItem {
+    constructor(
+        action,
+        options,
+        tooltip,
+        onUserDismissedTooltip,
+        commandService,
+        hoverService,
+        telemetryService,
+        updateService
+    ) {
+        super(undefined, action, options);
+        this.tooltip = tooltip;
+        this.onUserDismissedTooltip = onUserDismissedTooltip;
+        this.commandService = commandService;
+        this.hoverService = hoverService;
+        this.telemetryService = telemetryService;
+        this.updateService = updateService;
+        this.showTooltipOnRender = false;
+        this.action.run = () => this.runAction();
+        this._register(this.updateService.onStateChange(state => this.onStateChange(state)));
+    }
+    render(container) {
+        super.render(container);
+        this.content = append(container, $(".update-indicator"));
+        this.updateTooltip();
+        this.onStateChange(this.updateService.state);
+        if (this.showTooltipOnRender) {
+            this.showTooltipOnRender = false;
+            scheduleAtNextAnimationFrame(getWindow(container), () => this.showTooltip());
+        }
+    }
+    showTooltip(focus = false) {
+        if (!this.content?.isConnected) {
+            this.showTooltipOnRender = true;
+            return;
+        }
+        this.hoverService.showInstantHover({
+            content: this.tooltip.domNode,
+            target: {
+                targetElements: [this.content],
+                dispose: () => {
+                    if (!!this.content?.isConnected) {
+                        this.onUserDismissedTooltip();
+                    }
+                }
+            },
+            persistence: {
+                sticky: true
+            },
+            appearance: {
+                showPointer: true,
+                compact: true
+            }
+        }, focus);
+    }
+    getHoverContents() {
+        return this.tooltip.domNode;
+    }
+    async runAction() {
+        let commandId;
+        switch (this.updateService.state.type) {
+        case StateType.AvailableForDownload:
+            commandId = "update.downloadNow";
+            break;
+        case StateType.Downloaded:
+            commandId = "update.install";
+            break;
+        case StateType.Ready:
+            commandId = "update.restart";
+            break;
+        default:
+            this.showTooltip(true);
+            return;
+        }
+        this.telemetryService.publicLog2("workbenchActionExecuted", {
+            id: commandId,
+            from: "titlebar"
+        });
+        await this.commandService.executeCommand(commandId);
+    }
+    onStateChange(state) {
+        if (!this.content) {
+            return;
+        }
+        clearNode(this.content);
+        this.content.classList.remove("prominent", "progress-indefinite", "progress-percent", "update-disabled");
+        this.content.style.removeProperty("--update-progress");
+        const label = append(this.content, $(".indicator-label"));
+        label.textContent = ( localize(14795, "Update"));
+        switch (state.type) {
+        case StateType.Disabled:
+            this.content.classList.add("update-disabled");
+            break;
+        case StateType.CheckingForUpdates:
+        case StateType.Overwriting:
+            this.renderProgressState(this.content);
+            break;
+        case StateType.AvailableForDownload:
+        case StateType.Downloaded:
+        case StateType.Ready:
+            this.content.classList.add("prominent");
+            break;
+        case StateType.Downloading:
+            this.renderProgressState(
+                this.content,
+                computeProgressPercent(state.downloadedBytes, state.totalBytes)
+            );
+            break;
+        case StateType.Updating:
+            this.renderProgressState(
+                this.content,
+                computeProgressPercent(state.currentProgress, state.maxProgress)
+            );
+            break;
+        }
+    }
+    renderProgressState(content, percentage) {
+        if (percentage !== undefined) {
+            content.classList.add("progress-percent");
+            content.style.setProperty("--update-progress", `${percentage}%`);
+        } else {
+            content.classList.add("progress-indefinite");
+        }
+    }
+};
+UpdateTitleBarEntry = ( __decorate([( __param(4, ICommandService)), ( __param(5, IHoverService)), ( __param(6, ITelemetryService)), ( __param(7, IUpdateService))], UpdateTitleBarEntry));
+
+export { UpdateTitleBarContribution, UpdateTitleBarEntry };

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

@@ -0,0 +1,66 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+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 { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { State } from "@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update";
+/**
+ * A stateful tooltip control for the update status.
+ */
+export declare class UpdateTooltip extends Disposable {
+    private readonly hostedByTitleBar;
+    private readonly clipboardService;
+    private readonly commandService;
+    private readonly configurationService;
+    private readonly hoverService;
+    private readonly markdownRendererService;
+    private readonly meteredConnectionService;
+    private readonly openerService;
+    private readonly productService;
+    private readonly requestService;
+    readonly domNode: HTMLElement;
+    private readonly titleNode;
+    private readonly productInfoNode;
+    private readonly productNameNode;
+    private readonly currentVersionNode;
+    private readonly currentVersionCopyValue;
+    private readonly latestVersionNode;
+    private readonly latestVersionCopyValue;
+    private readonly releaseDateNode;
+    private readonly releaseNotesLink;
+    private readonly progressContainer;
+    private readonly progressFill;
+    private readonly progressPercentNode;
+    private readonly progressSizeNode;
+    private readonly downloadStatsContainer;
+    private readonly timeRemainingNode;
+    private readonly speedInfoNode;
+    private readonly markdownContainer;
+    private readonly markdown;
+    private readonly messageNode;
+    private releaseNotesVersion;
+    constructor(hostedByTitleBar: boolean, clipboardService: IClipboardService, commandService: ICommandService, configurationService: IConfigurationService, hoverService: IHoverService, markdownRendererService: IMarkdownRendererService, meteredConnectionService: IMeteredConnectionService, openerService: IOpenerService, productService: IProductService, requestService: IRequestService);
+    private updateCurrentVersion;
+    private hideAll;
+    renderState(state: State): void;
+    private renderUninitialized;
+    private renderDisabled;
+    private renderIdle;
+    private renderCheckingForUpdates;
+    private renderAvailableForDownload;
+    private renderDownloading;
+    private renderDownloaded;
+    private renderUpdating;
+    private renderReady;
+    private renderOverwriting;
+    renderPostInstall(): Promise<void>;
+    private renderTitleAndInfo;
+    private renderMessage;
+    private createVersionRow;
+    private runCommandAndClose;
+}