@codingame/monaco-vscode-update-service-override 37.2.0 → 37.3.0

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

@@ -1,65 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IActivityService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
-import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { IUpdateService } from "@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update.service";
-import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
-import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
-import { IBrowserWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/browser/environmentService.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 { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
-import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
-import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
-import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
-export declare const CONTEXT_UPDATE_STATE: RawContextKey<string>;
-export declare const MAJOR_MINOR_UPDATE_AVAILABLE: RawContextKey<boolean>;
-export declare function showReleaseNotesInEditor(instantiationService: IInstantiationService, version: string, useCurrentFile: boolean): Promise<boolean>;
-/**
- * Appends update-related menu items to the given menu. This registers menu items
- * for all update states (idle, checking, downloading, etc.) that show the current
- * update status. The underlying commands (`update.check`, `update.restart`, etc.)
- * must be registered separately.
- */
-export declare function appendUpdateMenuItems(menuId: MenuId, group: string): void;
-export declare class ProductContribution implements IWorkbenchContribution {
-    private static readonly KEY;
-    constructor(storageService: IStorageService, instantiationService: IInstantiationService, notificationService: INotificationService, environmentService: IBrowserWorkbenchEnvironmentService, openerService: IOpenerService, configurationService: IConfigurationService, hostService: IHostService, productService: IProductService);
-}
-export declare class UpdateContribution extends Disposable implements IWorkbenchContribution {
-    private readonly instantiationService;
-    private readonly dialogService;
-    private readonly updateService;
-    private readonly activityService;
-    private readonly contextKeyService;
-    private readonly productService;
-    private readonly hostService;
-    private state;
-    private readonly badgeDisposable;
-    private updateStateContextKey;
-    private majorMinorUpdateAvailableContextKey;
-    constructor(storageService: IStorageService, instantiationService: IInstantiationService, dialogService: IDialogService, updateService: IUpdateService, activityService: IActivityService, contextKeyService: IContextKeyService, productService: IProductService, hostService: IHostService);
-    private onUpdateStateChange;
-    private updateBadge;
-    private registerGlobalActivityActions;
-}
-export declare class SwitchProductQualityContribution extends Disposable implements IWorkbenchContribution {
-    private readonly productService;
-    private readonly environmentService;
-    constructor(productService: IProductService, environmentService: IBrowserWorkbenchEnvironmentService);
-    private registerGlobalActivityActions;
-}
-export declare class DefaultAccountUpdateContribution extends Disposable implements IWorkbenchContribution {
-    #private;
-    private readonly updateService;
-    private readonly defaultAccountService;
-    private readonly storageService;
-    private static readonly STORAGE_KEY;
-    private throttler;
-    constructor(updateService: IUpdateService, defaultAccountService: IDefaultAccountService, storageService: IStorageService);
-    private refresh;
-    private doRefresh;
-}

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

@@ -1,498 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
-import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { NumberBadge, ProgressBadge } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity';
-import { IActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.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 { StateType } 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 { NotificationPriority } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
-import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
-import { IBrowserWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/browser/environmentService.service';
-import { ReleaseNotesManager } from './releaseNotesEditor.js';
-import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { RawContextKey, ContextKeyExpr } 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 { MenuRegistry, MenuId, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
-import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
-import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
-import { SyncStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync';
-import { IUserDataSyncEnablementService, IUserDataSyncStoreManagementService, IUserDataSyncService } from '@codingame/monaco-vscode-api/vscode/vs/platform/userDataSync/common/userDataSync.service';
-import { IsWebContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
-import { Promises, Throttler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { IUserDataSyncWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataSync/common/userDataSync.service';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
-import { getInternalOrg } from '@codingame/monaco-vscode-api/vscode/vs/platform/assignment/common/assignment';
-import { tryParseVersion } from '../common/updateUtils.js';
-import { UpdateGlobalActivityBadgeVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/update/common/update';
-
-var ProductContribution_1, DefaultAccountUpdateContribution_1;
-const CONTEXT_UPDATE_STATE = ( new RawContextKey("updateState", StateType.Uninitialized));
-const MAJOR_MINOR_UPDATE_AVAILABLE = ( new RawContextKey("majorMinorUpdateAvailable", false));
-let releaseNotesManager = undefined;
-function showReleaseNotesInEditor(instantiationService, version, useCurrentFile) {
-    if (!releaseNotesManager) {
-        releaseNotesManager = instantiationService.createInstance(ReleaseNotesManager);
-    }
-    return releaseNotesManager.show(version, useCurrentFile);
-}
-async function openLatestReleaseNotesInBrowser(accessor) {
-    const openerService = accessor.get(IOpenerService);
-    const productService = accessor.get(IProductService);
-    if (productService.releaseNotesUrl) {
-        const uri = ( URI.parse(productService.releaseNotesUrl));
-        await openerService.open(uri);
-    } else {
-        throw ( new Error(( localize(
-            18375,
-            "This version of {0} does not have release notes online",
-            productService.nameLong
-        ))));
-    }
-}
-async function showReleaseNotes(accessor, version) {
-    const instantiationService = accessor.get(IInstantiationService);
-    try {
-        await showReleaseNotesInEditor(instantiationService, version, false);
-    } catch (err) {
-        try {
-            await instantiationService.invokeFunction(openLatestReleaseNotesInBrowser);
-        } catch (err2) {
-            throw ( new Error(`${err.message} and ${err2.message}`));
-        }
-    }
-}
-function appendUpdateMenuItems(menuId, group) {
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.check",
-            title: ( localize(18376, "Check for Updates..."))
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Idle))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.checking",
-            title: ( localize(18377, "Checking for Updates...")),
-            precondition: ( ContextKeyExpr.false())
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.CheckingForUpdates))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.downloadNow",
-            title: ( localize(18378, "Download Update (1)"))
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.AvailableForDownload))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.downloading",
-            title: ( localize(18379, "Downloading Update...")),
-            precondition: ( ContextKeyExpr.false())
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloading))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.install",
-            title: ( localize(18380, "Install Update... (1)"))
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloaded))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.updating",
-            title: ( localize(18381, "Installing Update...")),
-            precondition: ( ContextKeyExpr.false())
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Updating))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        command: {
-            id: "update.cancelling",
-            title: ( localize(18382, "Cancelling Update...")),
-            precondition: ( ContextKeyExpr.false())
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Cancelling))
-    });
-    MenuRegistry.appendMenuItem(menuId, {
-        group,
-        order: 2,
-        command: {
-            id: "update.restart",
-            title: ( localize(18383, "Restart to Update (1)"))
-        },
-        when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready))
-    });
-}
-function isMajorMinorUpdate(before, after) {
-    return before.major < after.major || before.minor < after.minor;
-}
-let ProductContribution = class ProductContribution {
-    static {
-        ProductContribution_1 = this;
-    }
-    static {
-        this.KEY = "releaseNotes/lastVersion";
-    }
-    constructor(
-        storageService,
-        instantiationService,
-        notificationService,
-        environmentService,
-        openerService,
-        configurationService,
-        hostService,
-        productService
-    ) {
-        if (isWeb) {
-            return;
-        }
-        hostService.hadLastFocus().then(async hadLastFocus => {
-            if (!hadLastFocus) {
-                return;
-            }
-            const lastVersion = tryParseVersion(
-                storageService.get(ProductContribution_1.KEY, StorageScope.APPLICATION, "")
-            );
-            const currentVersion = tryParseVersion(productService.version);
-            const shouldShowReleaseNotes = configurationService.getValue("update.showReleaseNotes");
-            const shouldShowPostInstallInfo = configurationService.getValue("update.showPostInstallInfo");
-            const releaseNotesUrl = productService.releaseNotesUrl;
-            if (shouldShowReleaseNotes && !shouldShowPostInstallInfo && !environmentService.skipReleaseNotes && releaseNotesUrl && lastVersion && currentVersion && isMajorMinorUpdate(lastVersion, currentVersion)) {
-                showReleaseNotesInEditor(instantiationService, productService.version, false).then(undefined, () => {
-                    notificationService.prompt(Severity.Info, ( localize(
-                        18384,
-                        "Welcome to {0} v{1}! Would you like to read the Release Notes?",
-                        productService.nameLong,
-                        productService.version
-                    )), [{
-                        label: ( localize(18385, "Release Notes")),
-                        run: () => {
-                            const uri = ( URI.parse(releaseNotesUrl));
-                            openerService.open(uri);
-                        }
-                    }], {
-                        priority: NotificationPriority.OPTIONAL
-                    });
-                });
-            }
-            storageService.store(
-                ProductContribution_1.KEY,
-                productService.version,
-                StorageScope.APPLICATION,
-                StorageTarget.MACHINE
-            );
-        });
-    }
-};
-ProductContribution = ProductContribution_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, IInstantiationService)), ( __param(2, INotificationService)), ( __param(3, IBrowserWorkbenchEnvironmentService)), ( __param(4, IOpenerService)), ( __param(5, IConfigurationService)), ( __param(6, IHostService)), ( __param(7, IProductService))], ProductContribution));
-let UpdateContribution = class UpdateContribution extends Disposable {
-    constructor(
-        storageService,
-        instantiationService,
-        dialogService,
-        updateService,
-        activityService,
-        contextKeyService,
-        productService,
-        hostService
-    ) {
-        super();
-        this.instantiationService = instantiationService;
-        this.dialogService = dialogService;
-        this.updateService = updateService;
-        this.activityService = activityService;
-        this.contextKeyService = contextKeyService;
-        this.productService = productService;
-        this.hostService = hostService;
-        this.badgeDisposable = this._register(( new MutableDisposable()));
-        this.state = updateService.state;
-        this.updateStateContextKey = CONTEXT_UPDATE_STATE.bindTo(contextKeyService);
-        this.majorMinorUpdateAvailableContextKey = MAJOR_MINOR_UPDATE_AVAILABLE.bindTo(contextKeyService);
-        this._register(updateService.onStateChange(this.onUpdateStateChange, this));
-        const updateGlobalActivityBadgeContextKeys = ( new Set(( UpdateGlobalActivityBadgeVisibleContext.keys())));
-        this._register(contextKeyService.onDidChangeContext(e => {
-            if (e.affectsSome(updateGlobalActivityBadgeContextKeys)) {
-                this.updateBadge(this.updateService.state);
-            }
-        }));
-        this.onUpdateStateChange(this.updateService.state);
-        const currentVersion = this.productService.commit;
-        const lastKnownVersion = storageService.get("update/lastKnownVersion", StorageScope.APPLICATION);
-        if (currentVersion !== lastKnownVersion) {
-            storageService.remove("update/lastKnownVersion", StorageScope.APPLICATION);
-            storageService.remove("update/updateNotificationTime", StorageScope.APPLICATION);
-        }
-        this.registerGlobalActivityActions();
-    }
-    async onUpdateStateChange(state) {
-        this.updateStateContextKey.set(state.type);
-        switch (state.type) {
-        case StateType.Idle:
-            if (state.notAvailable && !state.error && (await this.hostService.hadLastFocus())) {
-                this.dialogService.info(( localize(18386, "There are currently no updates available.")));
-            }
-            break;
-        case StateType.Ready:
-            {
-                const productVersion = state.update.productVersion;
-                if (productVersion) {
-                    const currentVersion = tryParseVersion(this.productService.version);
-                    const nextVersion = tryParseVersion(productVersion);
-                    this.majorMinorUpdateAvailableContextKey.set(Boolean(
-                        currentVersion && nextVersion && isMajorMinorUpdate(currentVersion, nextVersion)
-                    ));
-                }
-                break;
-            }
-        }
-        this.updateBadge(state);
-        this.state = state;
-    }
-    updateBadge(state) {
-        let badge;
-        if (state.type === StateType.AvailableForDownload || state.type === StateType.Downloaded || state.type === StateType.Ready) {
-            badge = ( new NumberBadge(1, () => ( localize(18387, "New {0} update available.", this.productService.nameShort))));
-        } else if (state.type === StateType.CheckingForUpdates) {
-            badge = ( new ProgressBadge(() => ( localize(18388, "Checking for {0} updates...", this.productService.nameShort))));
-        } else if (state.type === StateType.Downloading || state.type === StateType.Overwriting) {
-            badge = ( new ProgressBadge(() => ( localize(18389, "Downloading {0} update...", this.productService.nameShort))));
-        } else if (state.type === StateType.Updating) {
-            badge = ( new ProgressBadge(() => ( localize(18390, "Updating {0}...", this.productService.nameShort))));
-        } else if (state.type === StateType.Cancelling) {
-            badge = ( new ProgressBadge(() => ( localize(18391, "Cancelling {0} update...", this.productService.nameShort))));
-        }
-        this.badgeDisposable.clear();
-        if (badge && this.contextKeyService.contextMatchesRules(UpdateGlobalActivityBadgeVisibleContext)) {
-            this.badgeDisposable.value = this.activityService.showGlobalActivity({
-                badge
-            });
-        }
-    }
-    registerGlobalActivityActions() {
-        CommandsRegistry.registerCommand("update.check", () => this.updateService.checkForUpdates(true));
-        CommandsRegistry.registerCommand("update.checking", () => {});
-        CommandsRegistry.registerCommand("update.downloadNow", () => this.updateService.downloadUpdate(true));
-        CommandsRegistry.registerCommand("update.downloading", () => {});
-        CommandsRegistry.registerCommand("update.install", () => this.updateService.applyUpdate());
-        CommandsRegistry.registerCommand("update.updating", () => {});
-        CommandsRegistry.registerCommand("update.cancelling", () => {});
-        CommandsRegistry.registerCommand("update.restart", () => this.updateService.quitAndInstall());
-        CommandsRegistry.registerCommand("_update.state", () => {
-            return this.state;
-        });
-        appendUpdateMenuItems(MenuId.GlobalActivity, "7_update");
-        if (this.productService.quality === "stable") {
-            CommandsRegistry.registerCommand("update.showUpdateReleaseNotes", () => {
-                if (this.updateService.state.type !== StateType.Ready) {
-                    return;
-                }
-                const productVersion = this.updateService.state.update.productVersion;
-                if (productVersion) {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
-                }
-            });
-            MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-                group: "7_update",
-                order: 1,
-                command: {
-                    id: "update.showUpdateReleaseNotes",
-                    title: ( localize(18392, "Show Update Release Notes"))
-                },
-                when: ( ContextKeyExpr.and(( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready)), MAJOR_MINOR_UPDATE_AVAILABLE))
-            });
-        }
-    }
-};
-UpdateContribution = ( __decorate([( __param(0, IStorageService)), ( __param(1, IInstantiationService)), ( __param(2, IDialogService)), ( __param(3, IUpdateService)), ( __param(4, IActivityService)), ( __param(5, IContextKeyService)), ( __param(6, IProductService)), ( __param(7, IHostService))], UpdateContribution));
-let SwitchProductQualityContribution = class SwitchProductQualityContribution extends Disposable {
-    constructor(productService, environmentService) {
-        super();
-        this.productService = productService;
-        this.environmentService = environmentService;
-        this.registerGlobalActivityActions();
-    }
-    registerGlobalActivityActions() {
-        const quality = this.productService.quality;
-        const productQualityChangeHandler = this.environmentService.options?.productQualityChangeHandler;
-        if (productQualityChangeHandler && (quality === "stable" || quality === "insider")) {
-            const newQuality = quality === "stable" ? "insider" : "stable";
-            const commandId = `update.switchQuality.${newQuality}`;
-            const isSwitchingToInsiders = newQuality === "insider";
-            this._register(registerAction2(class SwitchQuality extends Action2 {
-                constructor() {
-                    super({
-                        id: commandId,
-                        title: isSwitchingToInsiders ? ( localize(18393, "Switch to Insiders Version...")) : ( localize(18394, "Switch to Stable Version...")),
-                        precondition: IsWebContext,
-                        menu: {
-                            id: MenuId.GlobalActivity,
-                            when: IsWebContext,
-                            group: "7_update"
-                        }
-                    });
-                }
-                async run(accessor) {
-                    const dialogService = accessor.get(IDialogService);
-                    const userDataSyncEnablementService = accessor.get(IUserDataSyncEnablementService);
-                    const userDataSyncStoreManagementService = accessor.get(IUserDataSyncStoreManagementService);
-                    const storageService = accessor.get(IStorageService);
-                    const userDataSyncWorkbenchService = accessor.get(IUserDataSyncWorkbenchService);
-                    const userDataSyncService = accessor.get(IUserDataSyncService);
-                    const notificationService = accessor.get(INotificationService);
-                    try {
-                        const selectSettingsSyncServiceDialogShownKey = "switchQuality.selectSettingsSyncServiceDialogShown";
-                        const userDataSyncStore = userDataSyncStoreManagementService.userDataSyncStore;
-                        let userDataSyncStoreType;
-                        if (userDataSyncStore && isSwitchingToInsiders && userDataSyncEnablementService.isEnabled() && !storageService.getBoolean(selectSettingsSyncServiceDialogShownKey, StorageScope.APPLICATION, false)) {
-                            userDataSyncStoreType = await this.selectSettingsSyncService(dialogService);
-                            if (!userDataSyncStoreType) {
-                                return;
-                            }
-                            storageService.store(
-                                selectSettingsSyncServiceDialogShownKey,
-                                true,
-                                StorageScope.APPLICATION,
-                                StorageTarget.USER
-                            );
-                            if (userDataSyncStoreType === "stable") {
-                                await userDataSyncStoreManagementService.switch(userDataSyncStoreType);
-                            }
-                        }
-                        const res = await dialogService.confirm({
-                            type: "info",
-                            message: ( localize(18395, "Changing the version requires a reload to take effect")),
-                            detail: newQuality === "insider" ? ( localize(
-                                18396,
-                                "Press the reload button to switch to the Insiders version of VS Code."
-                            )) : ( localize(
-                                18397,
-                                "Press the reload button to switch to the Stable version of VS Code."
-                            )),
-                            primaryButton: ( localize(18398, "&&Reload"))
-                        });
-                        if (res.confirmed) {
-                            const promises = [];
-                            if (userDataSyncService.status === SyncStatus.Syncing) {
-                                promises.push(Event.toPromise(Event.filter(
-                                    userDataSyncService.onDidChangeStatus,
-                                    status => status !== SyncStatus.Syncing
-                                )));
-                            }
-                            if (isSwitchingToInsiders && userDataSyncStoreType) {
-                                promises.push(userDataSyncWorkbenchService.synchroniseUserDataSyncStoreType());
-                            }
-                            await Promises.settled(promises);
-                            productQualityChangeHandler(newQuality);
-                        } else {
-                            if (userDataSyncStoreType) {
-                                storageService.remove(selectSettingsSyncServiceDialogShownKey, StorageScope.APPLICATION);
-                            }
-                        }
-                    } catch (error) {
-                        notificationService.error(error);
-                    }
-                }
-                async selectSettingsSyncService(dialogService) {
-                    const {
-                        result
-                    } = await dialogService.prompt({
-                        type: Severity.Info,
-                        message: ( localize(
-                            18399,
-                            "Choose the settings sync service to use after changing the version"
-                        )),
-                        detail: ( localize(
-                            18400,
-                            "The Insiders version of VS Code will synchronize your settings, keybindings, extensions, snippets and UI State using separate insiders settings sync service by default."
-                        )),
-                        buttons: [{
-                            label: ( localize(18401, "&&Insiders")),
-                            run: () => "insiders"
-                        }, {
-                            label: ( localize(18402, "&&Stable (current)")),
-                            run: () => "stable"
-                        }],
-                        cancelButton: true
-                    });
-                    return result;
-                }
-            }));
-        }
-    }
-};
-SwitchProductQualityContribution = ( __decorate([( __param(0, IProductService)), ( __param(1, IBrowserWorkbenchEnvironmentService))], SwitchProductQualityContribution));
-let DefaultAccountUpdateContribution = class DefaultAccountUpdateContribution extends Disposable {
-    static {
-        DefaultAccountUpdateContribution_1 = this;
-    }
-    static {
-        this.STORAGE_KEY = "update/internalOrg";
-    }
-    #internalOrg;
-    constructor(updateService, defaultAccountService, storageService) {
-        super();
-        this.updateService = updateService;
-        this.defaultAccountService = defaultAccountService;
-        this.storageService = storageService;
-        this.#internalOrg = undefined;
-        this.throttler = this._register(( new Throttler()));
-        if (isWeb) {
-            return;
-        }
-        this.#internalOrg = this.storageService.get(
-            DefaultAccountUpdateContribution_1.STORAGE_KEY,
-            StorageScope.APPLICATION,
-            undefined
-        );
-        this.throttler.queue(() => this.updateService.setInternalOrg(this.#internalOrg));
-        this.refresh();
-        this._register(this.defaultAccountService.onDidChangeDefaultAccount(() => this.refresh()));
-    }
-    refresh() {
-        this.throttler.queue(() => this.doRefresh());
-    }
-    async doRefresh() {
-        try {
-            const defaultAccount = await this.defaultAccountService.getDefaultAccount();
-            const internalOrg = getInternalOrg(defaultAccount?.entitlementsData?.organization_login_list);
-            if (internalOrg === this.#internalOrg) {
-                return;
-            }
-            this.#internalOrg = internalOrg;
-            await this.updateService.setInternalOrg(this.#internalOrg);
-            if (this.#internalOrg) {
-                this.storageService.store(
-                    DefaultAccountUpdateContribution_1.STORAGE_KEY,
-                    internalOrg,
-                    StorageScope.APPLICATION,
-                    StorageTarget.MACHINE
-                );
-            } else {
-                this.storageService.remove(DefaultAccountUpdateContribution_1.STORAGE_KEY, StorageScope.APPLICATION);
-            }
-        } catch (error) {}
-    }
-};
-DefaultAccountUpdateContribution = DefaultAccountUpdateContribution_1 = ( __decorate([( __param(0, IUpdateService)), ( __param(1, IDefaultAccountService)), ( __param(2, IStorageService))], DefaultAccountUpdateContribution));
-
-export { CONTEXT_UPDATE_STATE, DefaultAccountUpdateContribution, MAJOR_MINOR_UPDATE_AVAILABLE, ProductContribution, SwitchProductQualityContribution, UpdateContribution, appendUpdateMenuItems, showReleaseNotesInEditor };

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

@@ -1,64 +0,0 @@
-import { BaseActionViewItem, IBaseActionViewItemOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
-import { IManagedHoverContent, IManagedHoverOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover";
-import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
-import { AnchorAlignment } from "@codingame/monaco-vscode-api/vscode/vs/base/common/layout";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IActionViewItemService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service";
-import { IMenuItem, 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 { ContextKeyExpression } 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 { 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 { 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 { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
-import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-import { UpdateTooltip } from "./updateTooltip.js";
-export declare function registerUpdateTitleBarMenuPlacement(menuId: MenuId, item?: Omit<IMenuItem, "command">): void;
-export declare function getAdditionalUpdateTitleBarMenuWhen(when?: ContextKeyExpression): ContextKeyExpression;
-/**
- * Displays update status and actions in the title bar.
- */
-export declare class UpdateTitleBarContribution extends Disposable implements IWorkbenchContribution {
-    private readonly configurationService;
-    private readonly hostService;
-    private readonly storageService;
-    private readonly context;
-    private readonly tooltip;
-    private state;
-    private entry;
-    private tooltipVisible;
-    private tooltipFocused;
-    constructor(actionViewItemService: IActionViewItemService, chatService: IChatService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, hostService: IHostService, instantiationService: IInstantiationService, storageService: IStorageService, updateService: IUpdateService);
-    private createEntry;
-    private onStateChange;
-}
-/**
- * Custom action view item for the update indicator in the title bar.
- */
-export declare class UpdateTitleBarEntry extends BaseActionViewItem {
-    private readonly anchorAlignment;
-    private readonly tooltip;
-    private readonly onDidShowTooltip;
-    private readonly onUserDismissedTooltip;
-    private readonly commandService;
-    private readonly hoverService;
-    private readonly telemetryService;
-    private readonly updateService;
-    private content;
-    private tooltipFocusOnRender;
-    private readonly visibleTooltip;
-    constructor(action: IAction, options: IBaseActionViewItemOptions, anchorAlignment: AnchorAlignment, tooltip: UpdateTooltip, onDidShowTooltip: (focus: boolean) => void, onUserDismissedTooltip: () => void, commandService: ICommandService, hoverService: IHoverService, telemetryService: ITelemetryService, updateService: IUpdateService);
-    render(container: HTMLElement): void;
-    showTooltip(focus?: boolean): void;
-    private focusTooltip;
-    protected getHoverContents(): IManagedHoverContent;
-    protected getHoverOptions(): IManagedHoverOptions;
-    private runAction;
-    private onStateChange;
-    private renderProgressState;
-}