@codingame/monaco-vscode-update-service-override 25.1.1 → 26.0.0

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

@@ -32,12 +32,13 @@ import { Promises } from '@codingame/monaco-vscode-api/vscode/vs/base/common/asy
 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 { toAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
 
 var ProductContribution_1;
-const CONTEXT_UPDATE_STATE = ( new RawContextKey('updateState', StateType.Uninitialized));
-const MAJOR_MINOR_UPDATE_AVAILABLE = ( new RawContextKey('majorMinorUpdateAvailable', false));
-const RELEASE_NOTES_URL = ( new RawContextKey('releaseNotesUrl', ''));
-const DOWNLOAD_URL = ( new RawContextKey('downloadUrl', ''));
+const CONTEXT_UPDATE_STATE = ( new RawContextKey("updateState", StateType.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) {
@@ -51,10 +52,9 @@ async function openLatestReleaseNotesInBrowser(accessor) {
     if (productService.releaseNotesUrl) {
         const uri = ( URI.parse(productService.releaseNotesUrl));
         await openerService.open(uri);
-    }
-    else {
+    } else {
         throw ( new Error(( localize(
-            12876,
+            13233,
             "This version of {0} does not have release notes online",
             productService.nameLong
         ))));
@@ -64,12 +64,10 @@ async function showReleaseNotes(accessor, version) {
     const instantiationService = accessor.get(IInstantiationService);
     try {
         await showReleaseNotesInEditor(instantiationService, version, false);
-    }
-    catch (err) {
+    } catch (err) {
         try {
             await instantiationService.invokeFunction(openLatestReleaseNotesInBrowser);
-        }
-        catch (err2) {
+        } catch (err2) {
             throw ( new Error(`${err.message} and ${err2.message}`));
         }
     }
@@ -89,9 +87,23 @@ 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) {
+    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);
@@ -103,48 +115,58 @@ let ProductContribution = class ProductContribution {
         if (isWeb) {
             return;
         }
-        hostService.hadLastFocus().then(async (hadLastFocus) => {
+        hostService.hadLastFocus().then(async hadLastFocus => {
             if (!hadLastFocus) {
                 return;
             }
-            const lastVersion = parseVersion(storageService.get(ProductContribution_1.KEY, StorageScope.APPLICATION, ''));
+            const lastVersion = parseVersion(
+                storageService.get(ProductContribution_1.KEY, StorageScope.APPLICATION, "")
+            );
             const currentVersion = parseVersion(productService.version);
-            const shouldShowReleaseNotes = configurationService.getValue('update.showReleaseNotes');
+            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, () => {
+                showReleaseNotesInEditor(instantiationService, productService.version, false).then(undefined, () => {
                     notificationService.prompt(Severity.Info, ( localize(
-                        12877,
+                        13234,
                         "Welcome to {0} v{1}! Would you like to read the Release Notes?",
                         productService.nameLong,
                         productService.version
                     )), [{
-                            label: ( localize(12878, "Release Notes")),
-                            run: () => {
-                                const uri = ( URI.parse(releaseNotesUrl));
-                                openerService.open(uri);
-                            }
-                        }], { priority: NotificationPriority.OPTIONAL });
+                        label: ( localize(13235, "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);
+            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)),
-    ( __param(8, IContextKeyService))
-], ProductContribution));
+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, configurationService, hostService) {
+    constructor(
+        storageService,
+        instantiationService,
+        notificationService,
+        dialogService,
+        updateService,
+        activityService,
+        contextKeyService,
+        productService,
+        openerService,
+        configurationService,
+        hostService
+    ) {
         super();
         this.storageService = storageService;
         this.instantiationService = instantiationService;
@@ -164,79 +186,83 @@ let UpdateContribution = class UpdateContribution extends Disposable {
         this._register(updateService.onStateChange(this.onUpdateStateChange, this));
         this.onUpdateStateChange(this.updateService.state);
         const currentVersion = this.productService.commit;
-        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', StorageScope.APPLICATION);
+        const lastKnownVersion = this.storageService.get("update/lastKnownVersion", StorageScope.APPLICATION);
         if (currentVersion !== lastKnownVersion) {
-            this.storageService.remove('update/lastKnownVersion', StorageScope.APPLICATION);
-            this.storageService.remove('update/updateNotificationTime', StorageScope.APPLICATION);
+            this.storageService.remove("update/lastKnownVersion", StorageScope.APPLICATION);
+            this.storageService.remove("update/updateNotificationTime", StorageScope.APPLICATION);
         }
         this.registerGlobalActivityActions();
     }
     async onUpdateStateChange(state) {
         this.updateStateContextKey.set(state.type);
         switch (state.type) {
-            case StateType.Disabled:
-                if (state.reason === DisablementReason.RunningAsAdmin) {
-                    this.notificationService.notify({
-                        severity: Severity.Info,
-                        message: ( localize(
-                            12879,
-                            "Updates are disabled because you are running the user-scope installation of {0} as Administrator.",
-                            this.productService.nameLong
-                        )),
-                        actions: {
-                            primary: [
-                                toAction({
-                                    id: '',
-                                    label: ( localize(12880, "Learn More")),
-                                    run: () => this.openerService.open('https://aka.ms/vscode-windows-setup')
-                                })
-                            ]
-                        },
-                        neverShowAgain: { id: 'no-updates-running-as-admin', }
-                    });
-                }
-                break;
-            case StateType.Idle:
-                if (state.error) {
-                    this.onError(state.error);
-                }
-                else if (this.state.type === StateType.CheckingForUpdates && this.state.explicit && (await this.hostService.hadLastFocus())) {
-                    this.onUpdateNotAvailable();
-                }
-                break;
-            case StateType.AvailableForDownload:
-                this.onUpdateAvailable(state.update);
-                break;
-            case StateType.Downloaded:
-                this.onUpdateDownloaded(state.update);
-                break;
-            case StateType.Ready: {
+        case StateType.Disabled:
+            if (state.reason === DisablementReason.RunningAsAdmin) {
+                this.notificationService.notify({
+                    severity: Severity.Info,
+                    message: ( localize(
+                        13236,
+                        "Updates are disabled because you are running the user-scope installation of {0} as Administrator.",
+                        this.productService.nameLong
+                    )),
+                    actions: {
+                        primary: [toAction({
+                            id: "",
+                            label: ( localize(13237, "Learn More")),
+                            run: () => this.openerService.open("https://aka.ms/vscode-windows-setup")
+                        })]
+                    },
+                    neverShowAgain: {
+                        id: "no-updates-running-as-admin"
+                    }
+                });
+            }
+            break;
+        case StateType.Idle:
+            if (state.error) {
+                this.onError(state.error);
+            } else if (this.state.type === StateType.CheckingForUpdates && this.state.explicit && (await this.hostService.hadLastFocus())) {
+                this.onUpdateNotAvailable();
+            }
+            break;
+        case StateType.AvailableForDownload:
+            this.onUpdateAvailable(state.update);
+            break;
+        case StateType.Downloaded:
+            this.onUpdateDownloaded(state.update);
+            break;
+        case StateType.Overwriting:
+            this.onUpdateOverwriting(state);
+            break;
+        case StateType.Ready:
+            {
                 const productVersion = state.update.productVersion;
                 if (productVersion) {
                     const currentVersion = parseVersion(this.productService.version);
                     const nextVersion = parseVersion(productVersion);
-                    this.majorMinorUpdateAvailableContextKey.set(Boolean(currentVersion && nextVersion && isMajorMinorUpdate(currentVersion, nextVersion)));
-                    this.onUpdateReady(state.update);
+                    this.majorMinorUpdateAvailableContextKey.set(Boolean(
+                        currentVersion && nextVersion && isMajorMinorUpdate(currentVersion, nextVersion)
+                    ));
                 }
+                this.onUpdateReady(state);
                 break;
             }
         }
         let badge = undefined;
         if (state.type === StateType.AvailableForDownload || state.type === StateType.Downloaded || state.type === StateType.Ready) {
-            badge = ( new NumberBadge(1, () => ( localize(12881, "New {0} update available.", this.productService.nameShort))));
-        }
-        else if (state.type === StateType.CheckingForUpdates) {
-            badge = ( new ProgressBadge(() => ( localize(12882, "Checking for {0} updates...", this.productService.nameShort))));
-        }
-        else if (state.type === StateType.Downloading) {
-            badge = ( new ProgressBadge(() => ( localize(12883, "Downloading {0} update...", this.productService.nameShort))));
-        }
-        else if (state.type === StateType.Updating) {
-            badge = ( new ProgressBadge(() => ( localize(12884, "Updating {0}...", this.productService.nameShort))));
+            badge = ( new NumberBadge(1, () => ( localize(13238, "New {0} update available.", this.productService.nameShort))));
+        } else if (state.type === StateType.CheckingForUpdates) {
+            badge = ( new ProgressBadge(() => ( localize(13239, "Checking for {0} updates...", this.productService.nameShort))));
+        } else if (state.type === StateType.Downloading || state.type === StateType.Overwriting) {
+            badge = ( new ProgressBadge(() => ( localize(13240, "Downloading {0} update...", this.productService.nameShort))));
+        } else if (state.type === StateType.Updating) {
+            badge = ( new ProgressBadge(() => ( localize(13241, "Updating {0}...", this.productService.nameShort))));
         }
         this.badgeDisposable.clear();
         if (badge) {
-            this.badgeDisposable.value = this.activityService.showGlobalActivity({ badge });
+            this.badgeDisposable.value = this.activityService.showGlobalActivity({
+                badge
+            });
         }
         this.state = state;
     }
@@ -244,15 +270,18 @@ let UpdateContribution = class UpdateContribution extends Disposable {
         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');
+        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.Error,
             message: error,
-            source: ( localize(12885, "Update Service")),
+            source: ( localize(13242, "Update Service"))
         });
     }
     onUpdateNotAvailable() {
-        this.dialogService.info(( localize(12886, "There are currently no updates available.")));
+        this.dialogService.info(( localize(13243, "There are currently no updates available.")));
     }
     onUpdateAvailable(update) {
         if (!this.shouldShowNotification()) {
@@ -262,24 +291,26 @@ let UpdateContribution = class UpdateContribution extends Disposable {
         if (!productVersion) {
             return;
         }
-        this.notificationService.prompt(Severity.Info, ( localize(12887, "There is an available update.")), [{
-                label: ( localize(12888, "Download Update")),
-                run: () => this.updateService.downloadUpdate()
-            }, {
-                label: ( localize(12889, "Later")),
-                run: () => { }
-            }, {
-                label: ( localize(12878, "Release Notes")),
-                run: () => {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
-                }
-            }], { priority: NotificationPriority.OPTIONAL });
+        this.notificationService.prompt(Severity.Info, ( localize(13244, "There is an available update.")), [{
+            label: ( localize(13245, "Download Update")),
+            run: () => this.updateService.downloadUpdate()
+        }, {
+            label: ( localize(13246, "Later")),
+            run: () => {}
+        }, {
+            label: ( localize(13235, "Release Notes")),
+            run: () => {
+                this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
+            }
+        }], {
+            priority: NotificationPriority.OPTIONAL
+        });
     }
     onUpdateDownloaded(update) {
         if (isMacintosh) {
             return;
         }
-        if (this.configurationService.getValue('update.enableWindowsBackgroundUpdates') && this.productService.target === 'user') {
+        if (this.configurationService.getValue("update.enableWindowsBackgroundUpdates") && this.productService.target === "user") {
             return;
         }
         if (!this.shouldShowNotification()) {
@@ -290,124 +321,162 @@ let UpdateContribution = class UpdateContribution extends Disposable {
             return;
         }
         this.notificationService.prompt(Severity.Info, ( localize(
-            12890,
+            13247,
             "There's an update available: {0} {1}",
             this.productService.nameLong,
             productVersion
         )), [{
-                label: ( localize(12891, "Install Update")),
-                run: () => this.updateService.applyUpdate()
-            }, {
-                label: ( localize(12889, "Later")),
-                run: () => { }
-            }, {
-                label: ( localize(12878, "Release Notes")),
-                run: () => {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
-                }
-            }], { priority: NotificationPriority.OPTIONAL });
+            label: ( localize(13248, "Install Update")),
+            run: () => this.updateService.applyUpdate()
+        }, {
+            label: ( localize(13246, "Later")),
+            run: () => {}
+        }, {
+            label: ( localize(13235, "Release Notes")),
+            run: () => {
+                this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
+            }
+        }], {
+            priority: NotificationPriority.OPTIONAL
+        });
     }
-    onUpdateReady(update) {
-        if (!(isWindows && this.productService.target !== 'user') && !this.shouldShowNotification()) {
-            return;
-        }
-        const actions = [{
-                label: ( localize(12892, "Update Now")),
+    onUpdateReady(state) {
+        if (state.overwrite && this.overwriteNotificationHandle) {
+            const handle = this.overwriteNotificationHandle;
+            this.overwriteNotificationHandle = undefined;
+            handle.progress.done();
+            handle.updateMessage(( localize(13249, "The newer update is ready to install.")));
+            handle.updateActions({
+                primary: [toAction({
+                    id: "update.restartToUpdate",
+                    label: ( localize(13250, "Restart to Update")),
+                    run: () => this.updateService.quitAndInstall()
+                })]
+            });
+        } else if ((isWindows && this.productService.target !== "user") || this.shouldShowNotification()) {
+            const actions = [{
+                label: ( localize(13251, "Update Now")),
                 run: () => this.updateService.quitAndInstall()
             }, {
-                label: ( localize(12889, "Later")),
-                run: () => { }
+                label: ( localize(13246, "Later")),
+                run: () => {}
             }];
-        const productVersion = update.productVersion;
-        if (productVersion) {
-            actions.push({
-                label: ( localize(12878, "Release Notes")),
-                run: () => {
-                    this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
-                }
+            const productVersion = state.update.productVersion;
+            if (productVersion) {
+                actions.push({
+                    label: ( localize(13235, "Release Notes")),
+                    run: () => {
+                        this.instantiationService.invokeFunction(accessor => showReleaseNotes(accessor, productVersion));
+                    }
+                });
+            }
+            this.notificationService.prompt(Severity.Info, ( localize(
+                13252,
+                "Restart {0} to apply the latest update.",
+                this.productService.nameLong
+            )), actions, {
+                sticky: true,
+                priority: NotificationPriority.OPTIONAL
             });
         }
-        this.notificationService.prompt(Severity.Info, ( localize(
-            12893,
-            "Restart {0} to apply the latest update.",
-            this.productService.nameLong
-        )), actions, {
+    }
+    onUpdateOverwriting(state) {
+        if (!state.explicit) {
+            return;
+        }
+        this.overwriteNotificationHandle = this.notificationService.notify({
+            severity: Severity.Info,
             sticky: true,
-            priority: NotificationPriority.OPTIONAL
+            message: ( localize(
+                13253,
+                "We found a newer update available and have started to download it. We'll let you know as soon as it's ready to install."
+            )),
+            source: ( localize(13242, "Update Service"))
         });
+        this.overwriteNotificationHandle.progress.infinite();
     }
     shouldShowNotification() {
         const currentVersion = this.productService.commit;
         const currentMillis = ( new Date()).getTime();
-        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', StorageScope.APPLICATION);
+        const lastKnownVersion = this.storageService.get("update/lastKnownVersion", StorageScope.APPLICATION);
         if (currentVersion !== lastKnownVersion) {
-            this.storageService.store('update/lastKnownVersion', currentVersion, StorageScope.APPLICATION, StorageTarget.MACHINE);
-            this.storageService.store('update/updateNotificationTime', currentMillis, StorageScope.APPLICATION, StorageTarget.MACHINE);
+            this.storageService.store(
+                "update/lastKnownVersion",
+                currentVersion,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+            this.storageService.store(
+                "update/updateNotificationTime",
+                currentMillis,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
         }
-        const updateNotificationMillis = this.storageService.getNumber('update/updateNotificationTime', StorageScope.APPLICATION, currentMillis);
+        const updateNotificationMillis = this.storageService.getNumber("update/updateNotificationTime", StorageScope.APPLICATION, currentMillis);
         const diffDays = (currentMillis - updateNotificationMillis) / (1000 * 60 * 60 * 24);
         return diffDays > 5;
     }
     registerGlobalActivityActions() {
-        CommandsRegistry.registerCommand('update.check', () => this.updateService.checkForUpdates(true));
+        CommandsRegistry.registerCommand("update.check", () => this.updateService.checkForUpdates(true));
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             command: {
-                id: 'update.check',
-                title: ( localize(12894, "Check for Updates..."))
+                id: "update.check",
+                title: ( localize(13254, "Check for Updates..."))
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Idle))
         });
-        CommandsRegistry.registerCommand('update.checking', () => { });
+        CommandsRegistry.registerCommand("update.checking", () => {});
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             command: {
-                id: 'update.checking',
-                title: ( localize(12895, "Checking for Updates...")),
+                id: "update.checking",
+                title: ( localize(13255, "Checking for Updates...")),
                 precondition: ( ContextKeyExpr.false())
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.CheckingForUpdates))
         });
-        CommandsRegistry.registerCommand('update.downloadNow', () => this.updateService.downloadUpdate());
+        CommandsRegistry.registerCommand("update.downloadNow", () => this.updateService.downloadUpdate());
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             command: {
-                id: 'update.downloadNow',
-                title: ( localize(12896, "Download Update (1)"))
+                id: "update.downloadNow",
+                title: ( localize(13256, "Download Update (1)"))
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.AvailableForDownload))
         });
-        CommandsRegistry.registerCommand('update.downloading', () => { });
+        CommandsRegistry.registerCommand("update.downloading", () => {});
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             command: {
-                id: 'update.downloading',
-                title: ( localize(12897, "Downloading Update...")),
+                id: "update.downloading",
+                title: ( localize(13257, "Downloading Update...")),
                 precondition: ( ContextKeyExpr.false())
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloading))
         });
-        CommandsRegistry.registerCommand('update.install', () => this.updateService.applyUpdate());
+        CommandsRegistry.registerCommand("update.install", () => this.updateService.applyUpdate());
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             command: {
-                id: 'update.install',
-                title: ( localize(12898, "Install Update... (1)"))
+                id: "update.install",
+                title: ( localize(13258, "Install Update... (1)"))
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloaded))
         });
-        CommandsRegistry.registerCommand('update.updating', () => { });
+        CommandsRegistry.registerCommand("update.updating", () => {});
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             command: {
-                id: 'update.updating',
-                title: ( localize(12899, "Installing Update...")),
+                id: "update.updating",
+                title: ( localize(13259, "Installing Update...")),
                 precondition: ( ContextKeyExpr.false())
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Updating))
         });
-        if (this.productService.quality === 'stable') {
-            CommandsRegistry.registerCommand('update.showUpdateReleaseNotes', () => {
+        if (this.productService.quality === "stable") {
+            CommandsRegistry.registerCommand("update.showUpdateReleaseNotes", () => {
                 if (this.updateService.state.type !== StateType.Ready) {
                     return;
                 }
@@ -417,43 +486,31 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 }
             });
             MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-                group: '7_update',
+                group: "7_update",
                 order: 1,
                 command: {
-                    id: 'update.showUpdateReleaseNotes',
-                    title: ( localize(12900, "Show Update Release Notes"))
+                    id: "update.showUpdateReleaseNotes",
+                    title: ( localize(13260, "Show Update Release Notes"))
                 },
                 when: ( ContextKeyExpr.and(( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready)), MAJOR_MINOR_UPDATE_AVAILABLE))
             });
         }
-        CommandsRegistry.registerCommand('update.restart', () => this.updateService.quitAndInstall());
+        CommandsRegistry.registerCommand("update.restart", () => this.updateService.quitAndInstall());
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
-            group: '7_update',
+            group: "7_update",
             order: 2,
             command: {
-                id: 'update.restart',
-                title: ( localize(12901, "Restart to Update (1)"))
+                id: "update.restart",
+                title: ( localize(13261, "Restart to Update (1)"))
             },
             when: ( CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready))
         });
-        CommandsRegistry.registerCommand('_update.state', () => {
+        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, IConfigurationService)),
-    ( __param(10, IHostService))
-], UpdateContribution));
+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, IConfigurationService)), ( __param(10, IHostService))], UpdateContribution));
 let SwitchProductQualityContribution = class SwitchProductQualityContribution extends Disposable {
     constructor(productService, environmentService) {
         super();
@@ -464,20 +521,20 @@ let SwitchProductQualityContribution = class SwitchProductQualityContribution ex
     registerGlobalActivityActions() {
         const quality = this.productService.quality;
         const productQualityChangeHandler = this.environmentService.options?.productQualityChangeHandler;
-        if (productQualityChangeHandler && (quality === 'stable' || quality === 'insider')) {
-            const newQuality = quality === 'stable' ? 'insider' : 'stable';
+        if (productQualityChangeHandler && (quality === "stable" || quality === "insider")) {
+            const newQuality = quality === "stable" ? "insider" : "stable";
             const commandId = `update.switchQuality.${newQuality}`;
-            const isSwitchingToInsiders = newQuality === 'insider';
+            const isSwitchingToInsiders = newQuality === "insider";
             this._register(registerAction2(class SwitchQuality extends Action2 {
                 constructor() {
                     super({
                         id: commandId,
-                        title: isSwitchingToInsiders ? ( localize(12902, "Switch to Insiders Version...")) : ( localize(12903, "Switch to Stable Version...")),
+                        title: isSwitchingToInsiders ? ( localize(13262, "Switch to Insiders Version...")) : ( localize(13263, "Switch to Stable Version...")),
                         precondition: IsWebContext,
                         menu: {
                             id: MenuId.GlobalActivity,
                             when: IsWebContext,
-                            group: '7_update',
+                            group: "7_update"
                         }
                     });
                 }
@@ -490,76 +547,78 @@ let SwitchProductQualityContribution = class SwitchProductQualityContribution ex
                     const userDataSyncService = accessor.get(IUserDataSyncService);
                     const notificationService = accessor.get(INotificationService);
                     try {
-                        const selectSettingsSyncServiceDialogShownKey = 'switchQuality.selectSettingsSyncServiceDialogShown';
+                        const selectSettingsSyncServiceDialogShownKey = "switchQuality.selectSettingsSyncServiceDialogShown";
                         const userDataSyncStore = userDataSyncStoreManagementService.userDataSyncStore;
                         let userDataSyncStoreType;
-                        if (userDataSyncStore && isSwitchingToInsiders && userDataSyncEnablementService.isEnabled()
-                            && !storageService.getBoolean(selectSettingsSyncServiceDialogShownKey, StorageScope.APPLICATION, false)) {
+                        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') {
+                            storageService.store(
+                                selectSettingsSyncServiceDialogShownKey,
+                                true,
+                                StorageScope.APPLICATION,
+                                StorageTarget.USER
+                            );
+                            if (userDataSyncStoreType === "stable") {
                                 await userDataSyncStoreManagementService.switch(userDataSyncStoreType);
                             }
                         }
                         const res = await dialogService.confirm({
-                            type: 'info',
-                            message: ( localize(12904, "Changing the version requires a reload to take effect")),
-                            detail: newQuality === 'insider' ?
-                                ( localize(
-                                12905,
+                            type: "info",
+                            message: ( localize(13264, "Changing the version requires a reload to take effect")),
+                            detail: newQuality === "insider" ? ( localize(
+                                13265,
                                 "Press the reload button to switch to the Insiders version of VS Code."
-                            )) :
-                                ( localize(
-                                12906,
+                            )) : ( localize(
+                                13266,
                                 "Press the reload button to switch to the Stable version of VS Code."
                             )),
-                            primaryButton: ( localize(12907, "&&Reload"))
+                            primaryButton: ( localize(13267, "&&Reload"))
                         });
                         if (res.confirmed) {
                             const promises = [];
                             if (userDataSyncService.status === SyncStatus.Syncing) {
-                                promises.push(Event.toPromise(Event.filter(userDataSyncService.onDidChangeStatus, status => 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 {
+                        } else {
                             if (userDataSyncStoreType) {
                                 storageService.remove(selectSettingsSyncServiceDialogShownKey, StorageScope.APPLICATION);
                             }
                         }
-                    }
-                    catch (error) {
+                    } catch (error) {
                         notificationService.error(error);
                     }
                 }
                 async selectSettingsSyncService(dialogService) {
-                    const { result } = await dialogService.prompt({
+                    const {
+                        result
+                    } = await dialogService.prompt({
                         type: Severity.Info,
                         message: ( localize(
-                            12908,
+                            13268,
                             "Choose the settings sync service to use after changing the version"
                         )),
                         detail: ( localize(
-                            12909,
+                            13269,
                             "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(12910, "&&Insiders")),
-                                run: () => 'insiders'
-                            },
-                            {
-                                label: ( localize(12911, "&&Stable (current)")),
-                                run: () => 'stable'
-                            }
-                        ],
+                        buttons: [{
+                            label: ( localize(13270, "&&Insiders")),
+                            run: () => "insiders"
+                        }, {
+                            label: ( localize(13271, "&&Stable (current)")),
+                            run: () => "stable"
+                        }],
                         cancelButton: true
                     });
                     return result;
@@ -568,9 +627,31 @@ let SwitchProductQualityContribution = class SwitchProductQualityContribution ex
         }
     }
 };
-SwitchProductQualityContribution = ( __decorate([
-    ( __param(0, IProductService)),
-    ( __param(1, IBrowserWorkbenchEnvironmentService))
-], SwitchProductQualityContribution));
+SwitchProductQualityContribution = ( __decorate([( __param(0, IProductService)), ( __param(1, IBrowserWorkbenchEnvironmentService))], SwitchProductQualityContribution));
+let DefaultAccountUpdateContribution = class DefaultAccountUpdateContribution extends Disposable {
+    constructor(updateService, defaultAccountService) {
+        super();
+        this.updateService = updateService;
+        this.defaultAccountService = defaultAccountService;
+        if (isWeb) {
+            return;
+        }
+        this.checkDefaultAccount();
+        this._register(this.defaultAccountService.onDidChangeDefaultAccount(() => {
+            this.checkDefaultAccount();
+        }));
+    }
+    async checkDefaultAccount() {
+        try {
+            const defaultAccount = await this.defaultAccountService.getDefaultAccount();
+            const shouldDisable = defaultAccount?.entitlementsData?.organization_login_list?.some(org => org.toLowerCase() === "visual-studio-code") ?? false;
+            if (shouldDisable) {
+                await this.updateService.disableProgressiveReleases();
+                this.dispose();
+            }
+        } catch (error) {}
+    }
+};
+DefaultAccountUpdateContribution = ( __decorate([( __param(0, IUpdateService)), ( __param(1, IDefaultAccountService))], DefaultAccountUpdateContribution));
 
-export { CONTEXT_UPDATE_STATE, DOWNLOAD_URL, MAJOR_MINOR_UPDATE_AVAILABLE, ProductContribution, RELEASE_NOTES_URL, SwitchProductQualityContribution, UpdateContribution, showReleaseNotesInEditor };
+export { CONTEXT_UPDATE_STATE, DOWNLOAD_URL, DefaultAccountUpdateContribution, MAJOR_MINOR_UPDATE_AVAILABLE, ProductContribution, RELEASE_NOTES_URL, SwitchProductQualityContribution, UpdateContribution, showReleaseNotesInEditor };