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

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

@@ -1,656 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import Severity from 'vscode/vscode/vs/base/common/severity';
-import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { NumberBadge, ProgressBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update';
-import { Severity as Severity$1, INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
-import { ReleaseNotesManager } from './releaseNotesEditor.js';
-import { isWeb, isWindows } from 'vscode/vscode/vs/base/common/platform';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { MenuRegistry, MenuId, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IUserDataSyncEnablementService, IUserDataSyncStoreManagementService, IUserDataSyncService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
-import { IsWebContext } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
-import { Promises } from 'vscode/vscode/vs/base/common/async';
-import { IUserDataSyncWorkbenchService } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-var ProductContribution_1;
-const CONTEXT_UPDATE_STATE = ( new RawContextKey('updateState', "uninitialized" ));
-const MAJOR_MINOR_UPDATE_AVAILABLE = ( new RawContextKey('majorMinorUpdateAvailable', false));
-const RELEASE_NOTES_URL = ( new RawContextKey('releaseNotesUrl', ''));
-const DOWNLOAD_URL = ( new RawContextKey('downloadUrl', ''));
-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(localizeWithPath('vs/workbench/contrib/update/browser/update', 'update.noReleaseNotesOnline', "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 parseVersion(version) {
-    const match = /([0-9]+)\.([0-9]+)\.([0-9]+)/.exec(version);
-    if (!match) {
-        return undefined;
-    }
-    return {
-        major: parseInt(match[1]),
-        minor: parseInt(match[2]),
-        patch: parseInt(match[3])
-    };
-}
-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, contextKeyService) {
-        if (productService.releaseNotesUrl) {
-            const releaseNotesUrlKey = RELEASE_NOTES_URL.bindTo(contextKeyService);
-            releaseNotesUrlKey.set(productService.releaseNotesUrl);
-        }
-        if (productService.downloadUrl) {
-            const downloadUrlKey = DOWNLOAD_URL.bindTo(contextKeyService);
-            downloadUrlKey.set(productService.downloadUrl);
-        }
-        if (isWeb) {
-            return;
-        }
-        hostService.hadLastFocus().then(async (hadLastFocus) => {
-            if (!hadLastFocus) {
-                return;
-            }
-            const lastVersion = parseVersion(storageService.get(ProductContribution_1.KEY, -1 , ''));
-            const currentVersion = parseVersion(productService.version);
-            const shouldShowReleaseNotes = configurationService.getValue('update.showReleaseNotes');
-            const releaseNotesUrl = productService.releaseNotesUrl;
-            if (shouldShowReleaseNotes && !environmentService.skipReleaseNotes && releaseNotesUrl && lastVersion && currentVersion && isMajorMinorUpdate(lastVersion, currentVersion)) {
-                showReleaseNotesInEditor(instantiationService, productService.version, false)
-                    .then(undefined, () => {
-                    notificationService.prompt(Severity.Info, ( localizeWithPath(
-                        'vs/workbench/contrib/update/browser/update',
-                        'read the release notes',
-                        "Welcome to {0} v{1}! Would you like to read the Release Notes?",
-                        productService.nameLong,
-                        productService.version
-                    )), [{
-                            label: ( localizeWithPath(
-                                'vs/workbench/contrib/update/browser/update',
-                                'releaseNotes',
-                                "Release Notes"
-                            )),
-                            run: () => {
-                                const uri = ( URI.parse(releaseNotesUrl));
-                                openerService.open(uri);
-                            }
-                        }]);
-                });
-            }
-            storageService.store(ProductContribution_1.KEY, productService.version, -1 , 1 );
-        });
-    }
-};
-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)),
-    ( __param(8, IContextKeyService))
-], ProductContribution));
-let UpdateContribution = class UpdateContribution extends Disposable {
-    constructor(storageService, instantiationService, notificationService, dialogService, updateService, activityService, contextKeyService, productService, openerService, hostService) {
-        super();
-        this.storageService = storageService;
-        this.instantiationService = instantiationService;
-        this.notificationService = notificationService;
-        this.dialogService = dialogService;
-        this.updateService = updateService;
-        this.activityService = activityService;
-        this.contextKeyService = contextKeyService;
-        this.productService = productService;
-        this.openerService = openerService;
-        this.hostService = hostService;
-        this.badgeDisposable = this._register(( new MutableDisposable()));
-        this.state = updateService.state;
-        this.updateStateContextKey = CONTEXT_UPDATE_STATE.bindTo(this.contextKeyService);
-        this.majorMinorUpdateAvailableContextKey = MAJOR_MINOR_UPDATE_AVAILABLE.bindTo(this.contextKeyService);
-        this._register(updateService.onStateChange(this.onUpdateStateChange, this));
-        this.onUpdateStateChange(this.updateService.state);
-        const currentVersion = this.productService.commit;
-        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', -1 );
-        if (currentVersion !== lastKnownVersion) {
-            this.storageService.remove('update/lastKnownVersion', -1 );
-            this.storageService.remove('update/updateNotificationTime', -1 );
-        }
-        this.registerGlobalActivityActions();
-    }
-    async onUpdateStateChange(state) {
-        this.updateStateContextKey.set(state.type);
-        switch (state.type) {
-            case "disabled" :
-                if (state.reason === 5 ) {
-                    this.notificationService.notify({
-                        severity: Severity$1.Info,
-                        message: ( localizeWithPath(
-                            'vs/workbench/contrib/update/browser/update',
-                            'update service disabled',
-                            "Updates are disabled because you are running the user-scope installation of {0} as Administrator.",
-                            this.productService.nameLong
-                        )),
-                        actions: {
-                            primary: [
-                                ( new Action('', ( localizeWithPath('vs/workbench/contrib/update/browser/update', 'learn more', "Learn More")), undefined, undefined, () => {
-                                    this.openerService.open('https://aka.ms/vscode-windows-setup');
-                                }))
-                            ]
-                        },
-                        neverShowAgain: { id: 'no-updates-running-as-admin', }
-                    });
-                }
-                break;
-            case "idle" :
-                if (state.error) {
-                    this.onError(state.error);
-                }
-                else if (this.state.type === "checking for updates"  && this.state.explicit && (await this.hostService.hadLastFocus())) {
-                    this.onUpdateNotAvailable();
-                }
-                break;
-            case "available for download" :
-                this.onUpdateAvailable(state.update);
-                break;
-            case "downloaded" :
-                this.onUpdateDownloaded(state.update);
-                break;
-            case "ready" : {
-                const currentVersion = parseVersion(this.productService.version);
-                const nextVersion = parseVersion(state.update.productVersion);
-                this.majorMinorUpdateAvailableContextKey.set(Boolean(currentVersion && nextVersion && isMajorMinorUpdate(currentVersion, nextVersion)));
-                this.onUpdateReady(state.update);
-                break;
-            }
-        }
-        let badge = undefined;
-        let priority = undefined;
-        if (state.type === "available for download"  || state.type === "downloaded"  || state.type === "ready" ) {
-            badge = ( new NumberBadge(1, () => ( localizeWithPath(
-                'vs/workbench/contrib/update/browser/update',
-                'updateIsReady',
-                "New {0} update available.",
-                this.productService.nameShort
-            ))));
-        }
-        else if (state.type === "checking for updates" ) {
-            badge = ( new ProgressBadge(() => ( localizeWithPath(
-                'vs/workbench/contrib/update/browser/update',
-                'checkingForUpdates',
-                "Checking for Updates..."
-            ))));
-            priority = 1;
-        }
-        else if (state.type === "downloading" ) {
-            badge = ( new ProgressBadge(() => ( localizeWithPath(
-                'vs/workbench/contrib/update/browser/update',
-                'downloading',
-                "Downloading..."
-            ))));
-            priority = 1;
-        }
-        else if (state.type === "updating" ) {
-            badge = ( new ProgressBadge(() => ( localizeWithPath('vs/workbench/contrib/update/browser/update', 'updating', "Updating..."))));
-            priority = 1;
-        }
-        this.badgeDisposable.clear();
-        if (badge) {
-            this.badgeDisposable.value = this.activityService.showGlobalActivity({ badge, priority });
-        }
-        this.state = state;
-    }
-    onError(error) {
-        if (/The request timed out|The network connection was lost/i.test(error)) {
-            return;
-        }
-        error = 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');
-        this.notificationService.notify({
-            severity: Severity$1.Error,
-            message: error,
-            source: ( localizeWithPath(
-                'vs/workbench/contrib/update/browser/update',
-                'update service',
-                "Update Service"
-            )),
-        });
-    }
-    onUpdateNotAvailable() {
-        this.dialogService.info(( localizeWithPath(
-            'vs/workbench/contrib/update/browser/update',
-            'noUpdatesAvailable',
-            "There are currently no updates available."
-        )));
-    }
-    onUpdateAvailable(update) {
-        if (!this.shouldShowNotification()) {
-            return;
-        }
-        this.notificationService.prompt(Severity.Info, ( localizeWithPath(
-            'vs/workbench/contrib/update/browser/update',
-            'thereIsUpdateAvailable',
-            "There is an available update."
-        )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'download update',
-                    "Download Update"
-                )),
-                run: () => this.updateService.downloadUpdate()
-            }, {
-                label: ( localizeWithPath('vs/workbench/contrib/update/browser/update', 'later', "Later")),
-                run: () => { }
-            }, {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'releaseNotes',
-                    "Release Notes"
-                )),
-                run: () => {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, update.productVersion));
-                }
-            }]);
-    }
-    onUpdateDownloaded(update) {
-        if (!this.shouldShowNotification()) {
-            return;
-        }
-        this.notificationService.prompt(Severity.Info, ( localizeWithPath(
-            'vs/workbench/contrib/update/browser/update',
-            'updateAvailable',
-            "There's an update available: {0} {1}",
-            this.productService.nameLong,
-            update.productVersion
-        )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'installUpdate',
-                    "Install Update"
-                )),
-                run: () => this.updateService.applyUpdate()
-            }, {
-                label: ( localizeWithPath('vs/workbench/contrib/update/browser/update', 'later', "Later")),
-                run: () => { }
-            }, {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'releaseNotes',
-                    "Release Notes"
-                )),
-                run: () => {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, update.productVersion));
-                }
-            }]);
-    }
-    onUpdateReady(update) {
-        if (!(isWindows && this.productService.target !== 'user') && !this.shouldShowNotification()) {
-            return;
-        }
-        const actions = [{
-                label: ( localizeWithPath('vs/workbench/contrib/update/browser/update', 'updateNow', "Update Now")),
-                run: () => this.updateService.quitAndInstall()
-            }, {
-                label: ( localizeWithPath('vs/workbench/contrib/update/browser/update', 'later', "Later")),
-                run: () => { }
-            }];
-        if (update.productVersion) {
-            actions.push({
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'releaseNotes',
-                    "Release Notes"
-                )),
-                run: () => {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, update.productVersion));
-                }
-            });
-        }
-        this.notificationService.prompt(Severity.Info, ( localizeWithPath(
-            'vs/workbench/contrib/update/browser/update',
-            'updateAvailableAfterRestart',
-            "Restart {0} to apply the latest update.",
-            this.productService.nameLong
-        )), actions, { sticky: true });
-    }
-    shouldShowNotification() {
-        const currentVersion = this.productService.commit;
-        const currentMillis = ( new Date()).getTime();
-        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', -1 );
-        if (currentVersion !== lastKnownVersion) {
-            this.storageService.store('update/lastKnownVersion', currentVersion, -1 , 1 );
-            this.storageService.store('update/updateNotificationTime', currentMillis, -1 , 1 );
-        }
-        const updateNotificationMillis = this.storageService.getNumber('update/updateNotificationTime', -1 , currentMillis);
-        const diffDays = (currentMillis - updateNotificationMillis) / (1000 * 60 * 60 * 24);
-        return diffDays > 5;
-    }
-    registerGlobalActivityActions() {
-        CommandsRegistry.registerCommand('update.check', () => this.updateService.checkForUpdates(true));
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            command: {
-                id: 'update.check',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'checkForUpdates',
-                    "Check for Updates..."
-                ))
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("idle" ))
-        });
-        CommandsRegistry.registerCommand('update.checking', () => { });
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            command: {
-                id: 'update.checking',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'checkingForUpdates',
-                    "Checking for Updates..."
-                )),
-                precondition: ( ContextKeyExpr.false())
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("checking for updates" ))
-        });
-        CommandsRegistry.registerCommand('update.downloadNow', () => this.updateService.downloadUpdate());
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            command: {
-                id: 'update.downloadNow',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'download update_1',
-                    "Download Update (1)"
-                ))
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("available for download" ))
-        });
-        CommandsRegistry.registerCommand('update.downloading', () => { });
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            command: {
-                id: 'update.downloading',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'DownloadingUpdate',
-                    "Downloading Update..."
-                )),
-                precondition: ( ContextKeyExpr.false())
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("downloading" ))
-        });
-        CommandsRegistry.registerCommand('update.install', () => this.updateService.applyUpdate());
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            command: {
-                id: 'update.install',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'installUpdate...',
-                    "Install Update... (1)"
-                ))
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("downloaded" ))
-        });
-        CommandsRegistry.registerCommand('update.updating', () => { });
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            command: {
-                id: 'update.updating',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'installingUpdate',
-                    "Installing Update..."
-                )),
-                precondition: ( ContextKeyExpr.false())
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("updating" ))
-        });
-        if (this.productService.quality === 'stable') {
-            CommandsRegistry.registerCommand('update.showUpdateReleaseNotes', () => {
-                if (this.updateService.state.type !== "ready" ) {
-                    return;
-                }
-                const version = this.updateService.state.update.version;
-                this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, version));
-            });
-            MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-                group: '7_update',
-                order: 1,
-                command: {
-                    id: 'update.showUpdateReleaseNotes',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/update/browser/update',
-                        'showUpdateReleaseNotes',
-                        "Show Update Release Notes"
-                    ))
-                },
-                when: ( ContextKeyExpr.and(( CONTEXT_UPDATE_STATE.isEqualTo("ready" )), MAJOR_MINOR_UPDATE_AVAILABLE))
-            });
-        }
-        CommandsRegistry.registerCommand('update.restart', () => this.updateService.quitAndInstall());
-        MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
-            order: 2,
-            command: {
-                id: 'update.restart',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/update/browser/update',
-                    'restartToUpdate',
-                    "Restart to Update (1)"
-                ))
-            },
-            when: ( CONTEXT_UPDATE_STATE.isEqualTo("ready" ))
-        });
-        CommandsRegistry.registerCommand('_update.state', () => {
-            return this.state;
-        });
-    }
-};
-UpdateContribution = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IDialogService)),
-    ( __param(4, IUpdateService)),
-    ( __param(5, IActivityService)),
-    ( __param(6, IContextKeyService)),
-    ( __param(7, IProductService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, 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';
-            registerAction2(class SwitchQuality extends Action2 {
-                constructor() {
-                    super({
-                        id: commandId,
-                        title: isSwitchingToInsiders ? ( localizeWithPath(
-                            'vs/workbench/contrib/update/browser/update',
-                            'switchToInsiders',
-                            "Switch to Insiders Version..."
-                        )) : ( localizeWithPath(
-                            'vs/workbench/contrib/update/browser/update',
-                            'switchToStable',
-                            "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, -1 , false)) {
-                            userDataSyncStoreType = await this.selectSettingsSyncService(dialogService);
-                            if (!userDataSyncStoreType) {
-                                return;
-                            }
-                            storageService.store(selectSettingsSyncServiceDialogShownKey, true, -1 , 0 );
-                            if (userDataSyncStoreType === 'stable') {
-                                await userDataSyncStoreManagementService.switch(userDataSyncStoreType);
-                            }
-                        }
-                        const res = await dialogService.confirm({
-                            type: 'info',
-                            message: ( localizeWithPath(
-                                'vs/workbench/contrib/update/browser/update',
-                                'relaunchMessage',
-                                "Changing the version requires a reload to take effect"
-                            )),
-                            detail: newQuality === 'insider' ?
-                                ( localizeWithPath(
-                                    'vs/workbench/contrib/update/browser/update',
-                                    'relaunchDetailInsiders',
-                                    "Press the reload button to switch to the Insiders version of VS Code."
-                                )) :
-                                ( localizeWithPath(
-                                    'vs/workbench/contrib/update/browser/update',
-                                    'relaunchDetailStable',
-                                    "Press the reload button to switch to the Stable version of VS Code."
-                                )),
-                            primaryButton: ( localizeWithPath(
-                                'vs/workbench/contrib/update/browser/update',
-                                { key: 'reload', comment: ['&& denotes a mnemonic'] },
-                                "&&Reload"
-                            ))
-                        });
-                        if (res.confirmed) {
-                            const promises = [];
-                            if (userDataSyncService.status === "syncing" ) {
-                                promises.push(Event.toPromise(Event.filter(userDataSyncService.onDidChangeStatus, status => status !== "syncing" )));
-                            }
-                            if (isSwitchingToInsiders && userDataSyncStoreType) {
-                                promises.push(userDataSyncWorkbenchService.synchroniseUserDataSyncStoreType());
-                            }
-                            await Promises.settled(promises);
-                            productQualityChangeHandler(newQuality);
-                        }
-                        else {
-                            if (userDataSyncStoreType) {
-                                storageService.remove(selectSettingsSyncServiceDialogShownKey, -1 );
-                            }
-                        }
-                    }
-                    catch (error) {
-                        notificationService.error(error);
-                    }
-                }
-                async selectSettingsSyncService(dialogService) {
-                    const { result } = await dialogService.prompt({
-                        type: Severity$1.Info,
-                        message: ( localizeWithPath(
-                            'vs/workbench/contrib/update/browser/update',
-                            'selectSyncService.message',
-                            "Choose the settings sync service to use after changing the version"
-                        )),
-                        detail: ( localizeWithPath(
-                            'vs/workbench/contrib/update/browser/update',
-                            'selectSyncService.detail',
-                            "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: ( localizeWithPath(
-                                    'vs/workbench/contrib/update/browser/update',
-                                    { key: 'use insiders', comment: ['&& denotes a mnemonic'] },
-                                    "&&Insiders"
-                                )),
-                                run: () => 'insiders'
-                            },
-                            {
-                                label: ( localizeWithPath(
-                                    'vs/workbench/contrib/update/browser/update',
-                                    { key: 'use stable', comment: ['&& denotes a mnemonic'] },
-                                    "&&Stable (current)"
-                                )),
-                                run: () => 'stable'
-                            }
-                        ],
-                        cancelButton: true
-                    });
-                    return result;
-                }
-            });
-        }
-    }
-};
-SwitchProductQualityContribution = ( __decorate([
-    ( __param(0, IProductService)),
-    ( __param(1, IBrowserWorkbenchEnvironmentService))
-], SwitchProductQualityContribution));
-
-export { CONTEXT_UPDATE_STATE, DOWNLOAD_URL, MAJOR_MINOR_UPDATE_AVAILABLE, ProductContribution, RELEASE_NOTES_URL, SwitchProductQualityContribution, UpdateContribution, showReleaseNotesInEditor };