@codingame/monaco-vscode-update-service-override 5.2.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-update-service-override",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@5.2.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@6.0.0"
   }
 }

package/update.js

@@ -1,7 +1,12 @@
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update.service';
+import { BrowserUpdateService } from './vscode/src/vs/workbench/services/update/browser/updateService.js';
 import './vscode/src/vs/workbench/contrib/update/browser/update.contribution.js';
 
 function getServiceOverride() {
-    return {};
+    return {
+        [( IUpdateService.toString())]: new SyncDescriptor(BrowserUpdateService, [], true)
+    };
 }
 
 export { getServiceOverride as default };

package/vscode/src/vs/platform/update/common/update.config.contribution.js

@@ -1,6 +1,6 @@
 import { isWindows, isWeb } from 'vscode/vscode/vs/base/common/platform';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Extensions, ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 
 const _moduleId = "vs/platform/update/common/update.config.contribution";
@@ -15,7 +15,7 @@ configurationRegistry.registerConfiguration({
             type: 'string',
             enum: ['none', 'manual', 'start', 'default'],
             default: 'default',
-            scope: 1 ,
+            scope: ConfigurationScope.APPLICATION,
             description: ( localizeWithPath(
                 _moduleId,
                 1,
@@ -48,7 +48,7 @@ configurationRegistry.registerConfiguration({
         'update.channel': {
             type: 'string',
             default: 'default',
-            scope: 1 ,
+            scope: ConfigurationScope.APPLICATION,
             description: ( localizeWithPath(
                 _moduleId,
                 1,
@@ -64,7 +64,7 @@ configurationRegistry.registerConfiguration({
         'update.enableWindowsBackgroundUpdates': {
             type: 'boolean',
             default: true,
-            scope: 1 ,
+            scope: ConfigurationScope.APPLICATION,
             title: ( localizeWithPath(_moduleId, 7, "Enable Background Updates on Windows")),
             description: ( localizeWithPath(
                 _moduleId,
@@ -76,7 +76,7 @@ configurationRegistry.registerConfiguration({
         'update.showReleaseNotes': {
             type: 'boolean',
             default: true,
-            scope: 1 ,
+            scope: ConfigurationScope.APPLICATION,
             description: ( localizeWithPath(
                 _moduleId,
                 9,

package/vscode/src/vs/workbench/contrib/markdown/browser/markdownSettingRenderer.js

@@ -3,6 +3,7 @@ import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences.service';
 import { settingKeyToDisplayFormat } from 'vscode/vscode/vs/workbench/contrib/preferences/browser/settingsTreeModels';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { ConfigurationTarget } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { DefaultSettings } from 'vscode/vscode/vs/workbench/services/preferences/common/preferencesModels';
 import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
@@ -23,7 +24,7 @@ let SimpleSettingRenderer = class SimpleSettingRenderer {
         this._encounteredSettings = ( (new Map()));
         this._featuredSettings = ( (new Map()));
         this.settingsGroups = undefined;
-        this._defaultSettings = ( (new DefaultSettings([], 2 )));
+        this._defaultSettings = ( (new DefaultSettings([], ConfigurationTarget.USER)));
     }
     get featuredSettingStates() {
         const result = ( (new Map()));
@@ -195,11 +196,11 @@ let SimpleSettingRenderer = class SimpleSettingRenderer {
     async restoreSetting(settingId) {
         const userOriginalSettingValue = this._updatedSettings.get(settingId);
         this._updatedSettings.delete(settingId);
-        return this._configurationService.updateValue(settingId, userOriginalSettingValue, 2 );
+        return this._configurationService.updateValue(settingId, userOriginalSettingValue, ConfigurationTarget.USER);
     }
     async setSetting(settingId, currentSettingValue, newSettingValue) {
         this._updatedSettings.set(settingId, currentSettingValue);
-        return this._configurationService.updateValue(settingId, newSettingValue, 2 );
+        return this._configurationService.updateValue(settingId, newSettingValue, ConfigurationTarget.USER);
     }
     getActions(uri) {
         if (uri.scheme !== Schemas.codeSetting) {

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

@@ -25,6 +25,7 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { supportsTelemetry, getTelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { TelemetryLevel } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { SimpleSettingRenderer } from '../../markdown/browser/markdownSettingRenderer.js';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
@@ -200,7 +201,7 @@ let ReleaseNotesManager = class ReleaseNotesManager {
         }
     }
     async addGAParameters(uri, origin, experiment = '1') {
-        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
+        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === TelemetryLevel.USAGE) {
             if (uri.scheme === 'https' && uri.authority === 'code.visualstudio.com') {
                 return uri.with({ query: `${uri.query ? uri.query + '&' : ''}utm_source=VsCode&utm_medium=${encodeURIComponent(origin)}&utm_content=${encodeURIComponent(experiment)}` });
             }

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

@@ -5,7 +5,9 @@ import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { Action2, MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { ProductContribution, UpdateContribution, SwitchProductQualityContribution, RELEASE_NOTES_URL, showReleaseNotesInEditor, CONTEXT_UPDATE_STATE, DOWNLOAD_URL } from './update.js';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import product$1 from 'vscode/vscode/vs/platform/product/common/product';
+import { StateType } from 'vscode/vscode/vs/platform/update/common/update';
 import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { isWindows } from 'vscode/vscode/vs/base/common/platform';
@@ -20,9 +22,9 @@ import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/cont
 
 const _moduleId = "vs/workbench/contrib/update/browser/update.contribution";
 const workbench = ( (Registry.as(Extensions.Workbench)));
-workbench.registerWorkbenchContribution(ProductContribution, 3 );
-workbench.registerWorkbenchContribution(UpdateContribution, 3 );
-workbench.registerWorkbenchContribution(SwitchProductQualityContribution, 3 );
+workbench.registerWorkbenchContribution(ProductContribution, LifecyclePhase.Restored);
+workbench.registerWorkbenchContribution(UpdateContribution, LifecyclePhase.Restored);
+workbench.registerWorkbenchContribution(SwitchProductQualityContribution, LifecyclePhase.Restored);
 class ShowCurrentReleaseNotesAction extends Action2 {
     constructor() {
         super({
@@ -99,7 +101,7 @@ class CheckForUpdateAction extends Action2 {
             title: ( localize2WithPath(_moduleId, 6, 'Check for Updates...')),
             category: { value: product$1.nameShort, original: product$1.nameShort },
             f1: true,
-            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo("idle" ))),
+            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Idle))),
         });
     }
     async run(accessor) {
@@ -114,7 +116,7 @@ class DownloadUpdateAction extends Action2 {
             title: ( localize2WithPath(_moduleId, 7, 'Download Update')),
             category: { value: product$1.nameShort, original: product$1.nameShort },
             f1: true,
-            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo("available for download" )))
+            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.AvailableForDownload)))
         });
     }
     async run(accessor) {
@@ -128,7 +130,7 @@ class InstallUpdateAction extends Action2 {
             title: ( localize2WithPath(_moduleId, 8, 'Install Update')),
             category: { value: product$1.nameShort, original: product$1.nameShort },
             f1: true,
-            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo("downloaded" )))
+            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloaded)))
         });
     }
     async run(accessor) {
@@ -142,7 +144,7 @@ class RestartToUpdateAction extends Action2 {
             title: ( localize2WithPath(_moduleId, 9, 'Restart to Update')),
             category: { value: product$1.nameShort, original: product$1.nameShort },
             f1: true,
-            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo("ready" )))
+            precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready)))
         });
     }
     async run(accessor) {
@@ -184,7 +186,7 @@ if (isWindows) {
                 title: ( localize2WithPath(_moduleId, 11, 'Apply Update...')),
                 category: Categories.Developer,
                 f1: true,
-                precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo("idle" )))
+                precondition: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Idle)))
             });
         }
         async run(accessor) {

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

@@ -7,7 +7,9 @@ import { NumberBadge, ProgressBadge } from 'vscode/vscode/vs/workbench/services/
 import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { StateType, DisablementReason } from 'vscode/vscode/vs/platform/update/common/update';
 import { IUpdateService } from 'vscode/vscode/vs/platform/update/common/update.service';
 import 'vscode/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
@@ -22,6 +24,7 @@ import { MenuRegistry, MenuId, registerAction2, Action2 } from 'vscode/vscode/vs
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { SyncStatus } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IUserDataSyncEnablementService, IUserDataSyncStoreManagementService, IUserDataSyncService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
 import { IsWebContext } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
 import { Promises } from 'vscode/vscode/vs/base/common/async';
@@ -31,7 +34,7 @@ import { Action } from 'vscode/vscode/vs/base/common/actions';
 
 var ProductContribution_1;
 const _moduleId = "vs/workbench/contrib/update/browser/update";
-const CONTEXT_UPDATE_STATE = ( (new RawContextKey('updateState', "uninitialized" )));
+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', '')));
@@ -105,7 +108,7 @@ let ProductContribution = class ProductContribution {
             if (!hadLastFocus) {
                 return;
             }
-            const lastVersion = parseVersion(storageService.get(ProductContribution_1.KEY, -1 , ''));
+            const lastVersion = parseVersion(storageService.get(ProductContribution_1.KEY, StorageScope.APPLICATION, ''));
             const currentVersion = parseVersion(productService.version);
             const shouldShowReleaseNotes = configurationService.getValue('update.showReleaseNotes');
             const releaseNotesUrl = productService.releaseNotesUrl;
@@ -127,7 +130,7 @@ let ProductContribution = class ProductContribution {
                         }]);
                 });
             }
-            storageService.store(ProductContribution_1.KEY, productService.version, -1 , 1 );
+            storageService.store(ProductContribution_1.KEY, productService.version, StorageScope.APPLICATION, StorageTarget.MACHINE);
         });
     }
 };
@@ -163,18 +166,18 @@ 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', -1 );
+        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', StorageScope.APPLICATION);
         if (currentVersion !== lastKnownVersion) {
-            this.storageService.remove('update/lastKnownVersion', -1 );
-            this.storageService.remove('update/updateNotificationTime', -1 );
+            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 "disabled" :
-                if (state.reason === 5 ) {
+            case StateType.Disabled:
+                if (state.reason === DisablementReason.RunningAsAdmin) {
                     this.notificationService.notify({
                         severity: Severity$1.Info,
                         message: ( localizeWithPath(
@@ -194,21 +197,21 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                     });
                 }
                 break;
-            case "idle" :
+            case StateType.Idle:
                 if (state.error) {
                     this.onError(state.error);
                 }
-                else if (this.state.type === "checking for updates"  && this.state.explicit && (await this.hostService.hadLastFocus())) {
+                else if (this.state.type === StateType.CheckingForUpdates && this.state.explicit && (await this.hostService.hadLastFocus())) {
                     this.onUpdateNotAvailable();
                 }
                 break;
-            case "available for download" :
+            case StateType.AvailableForDownload:
                 this.onUpdateAvailable(state.update);
                 break;
-            case "downloaded" :
+            case StateType.Downloaded:
                 this.onUpdateDownloaded(state.update);
                 break;
-            case "ready" : {
+            case StateType.Ready: {
                 const productVersion = state.update.productVersion;
                 if (productVersion) {
                     const currentVersion = parseVersion(this.productService.version);
@@ -221,18 +224,18 @@ let UpdateContribution = class UpdateContribution extends Disposable {
         }
         let badge = undefined;
         let priority = undefined;
-        if (state.type === "available for download"  || state.type === "downloaded"  || state.type === "ready" ) {
+        if (state.type === StateType.AvailableForDownload || state.type === StateType.Downloaded || state.type === StateType.Ready) {
             badge = ( (new NumberBadge(1, () => ( localizeWithPath(_moduleId, 5, "New {0} update available.", this.productService.nameShort)))));
         }
-        else if (state.type === "checking for updates" ) {
+        else if (state.type === StateType.CheckingForUpdates) {
             badge = ( (new ProgressBadge(() => ( localizeWithPath(_moduleId, 6, "Checking for Updates...")))));
             priority = 1;
         }
-        else if (state.type === "downloading" ) {
+        else if (state.type === StateType.Downloading) {
             badge = ( (new ProgressBadge(() => ( localizeWithPath(_moduleId, 7, "Downloading...")))));
             priority = 1;
         }
-        else if (state.type === "updating" ) {
+        else if (state.type === StateType.Updating) {
             badge = ( (new ProgressBadge(() => ( localizeWithPath(_moduleId, 8, "Updating...")))));
             priority = 1;
         }
@@ -340,12 +343,12 @@ let UpdateContribution = class UpdateContribution extends Disposable {
     shouldShowNotification() {
         const currentVersion = this.productService.commit;
         const currentMillis = ( (new Date())).getTime();
-        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', -1 );
+        const lastKnownVersion = this.storageService.get('update/lastKnownVersion', StorageScope.APPLICATION);
         if (currentVersion !== lastKnownVersion) {
-            this.storageService.store('update/lastKnownVersion', currentVersion, -1 , 1 );
-            this.storageService.store('update/updateNotificationTime', currentMillis, -1 , 1 );
+            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', -1 , currentMillis);
+        const updateNotificationMillis = this.storageService.getNumber('update/updateNotificationTime', StorageScope.APPLICATION, currentMillis);
         const diffDays = (currentMillis - updateNotificationMillis) / (1000 * 60 * 60 * 24);
         return diffDays > 5;
     }
@@ -357,7 +360,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 id: 'update.check',
                 title: ( localizeWithPath(_moduleId, 18, "Check for Updates..."))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("idle" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Idle)))
         });
         CommandsRegistry.registerCommand('update.checking', () => { });
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
@@ -367,7 +370,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 title: ( localizeWithPath(_moduleId, 6, "Checking for Updates...")),
                 precondition: ( (ContextKeyExpr.false()))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("checking for updates" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.CheckingForUpdates)))
         });
         CommandsRegistry.registerCommand('update.downloadNow', () => this.updateService.downloadUpdate());
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
@@ -376,7 +379,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 id: 'update.downloadNow',
                 title: ( localizeWithPath(_moduleId, 19, "Download Update (1)"))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("available for download" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.AvailableForDownload)))
         });
         CommandsRegistry.registerCommand('update.downloading', () => { });
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
@@ -386,7 +389,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 title: ( localizeWithPath(_moduleId, 20, "Downloading Update...")),
                 precondition: ( (ContextKeyExpr.false()))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("downloading" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloading)))
         });
         CommandsRegistry.registerCommand('update.install', () => this.updateService.applyUpdate());
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
@@ -395,7 +398,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 id: 'update.install',
                 title: ( localizeWithPath(_moduleId, 21, "Install Update... (1)"))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("downloaded" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Downloaded)))
         });
         CommandsRegistry.registerCommand('update.updating', () => { });
         MenuRegistry.appendMenuItem(MenuId.GlobalActivity, {
@@ -405,11 +408,11 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 title: ( localizeWithPath(_moduleId, 22, "Installing Update...")),
                 precondition: ( (ContextKeyExpr.false()))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("updating" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Updating)))
         });
         if (this.productService.quality === 'stable') {
             CommandsRegistry.registerCommand('update.showUpdateReleaseNotes', () => {
-                if (this.updateService.state.type !== "ready" ) {
+                if (this.updateService.state.type !== StateType.Ready) {
                     return;
                 }
                 const productVersion = this.updateService.state.update.productVersion;
@@ -425,7 +428,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                     title: ( localizeWithPath(_moduleId, 23, "Show Update Release Notes"))
                 },
                 when: ( (ContextKeyExpr.and(
-                     (CONTEXT_UPDATE_STATE.isEqualTo("ready" )),
+                     (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready)),
                     MAJOR_MINOR_UPDATE_AVAILABLE
                 )))
             });
@@ -438,7 +441,7 @@ let UpdateContribution = class UpdateContribution extends Disposable {
                 id: 'update.restart',
                 title: ( localizeWithPath(_moduleId, 24, "Restart to Update (1)"))
             },
-            when: ( (CONTEXT_UPDATE_STATE.isEqualTo("ready" )))
+            when: ( (CONTEXT_UPDATE_STATE.isEqualTo(StateType.Ready)))
         });
         CommandsRegistry.registerCommand('_update.state', () => {
             return this.state;
@@ -498,12 +501,12 @@ let SwitchProductQualityContribution = class SwitchProductQualityContribution ex
                         const userDataSyncStore = userDataSyncStoreManagementService.userDataSyncStore;
                         let userDataSyncStoreType;
                         if (userDataSyncStore && isSwitchingToInsiders && userDataSyncEnablementService.isEnabled()
-                            && !storageService.getBoolean(selectSettingsSyncServiceDialogShownKey, -1 , false)) {
+                            && !storageService.getBoolean(selectSettingsSyncServiceDialogShownKey, StorageScope.APPLICATION, false)) {
                             userDataSyncStoreType = await this.selectSettingsSyncService(dialogService);
                             if (!userDataSyncStoreType) {
                                 return;
                             }
-                            storageService.store(selectSettingsSyncServiceDialogShownKey, true, -1 , 0 );
+                            storageService.store(selectSettingsSyncServiceDialogShownKey, true, StorageScope.APPLICATION, StorageTarget.USER);
                             if (userDataSyncStoreType === 'stable') {
                                 await userDataSyncStoreManagementService.switch(userDataSyncStoreType);
                             }
@@ -526,8 +529,8 @@ let SwitchProductQualityContribution = class SwitchProductQualityContribution ex
                         });
                         if (res.confirmed) {
                             const promises = [];
-                            if (userDataSyncService.status === "syncing" ) {
-                                promises.push(Event.toPromise(Event.filter(userDataSyncService.onDidChangeStatus, status => status !== "syncing" )));
+                            if (userDataSyncService.status === SyncStatus.Syncing) {
+                                promises.push(Event.toPromise(Event.filter(userDataSyncService.onDidChangeStatus, status => status !== SyncStatus.Syncing)));
                             }
                             if (isSwitchingToInsiders && userDataSyncStoreType) {
                                 promises.push(userDataSyncWorkbenchService.synchroniseUserDataSyncStoreType());
@@ -537,7 +540,7 @@ let SwitchProductQualityContribution = class SwitchProductQualityContribution ex
                         }
                         else {
                             if (userDataSyncStoreType) {
-                                storageService.remove(selectSettingsSyncServiceDialogShownKey, -1 );
+                                storageService.remove(selectSettingsSyncServiceDialogShownKey, StorageScope.APPLICATION);
                             }
                         }
                     }

package/vscode/src/vs/workbench/services/update/browser/updateService.js

@@ -0,0 +1,66 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { State, UpdateType } from 'vscode/vscode/vs/platform/update/common/update';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+
+let BrowserUpdateService = class BrowserUpdateService extends Disposable {
+    get state() { return this._state; }
+    set state(state) {
+        this._state = state;
+        this._onStateChange.fire(state);
+    }
+    constructor(environmentService, hostService) {
+        super();
+        this.environmentService = environmentService;
+        this.hostService = hostService;
+        this._onStateChange = this._register(( new Emitter()));
+        this.onStateChange = this._onStateChange.event;
+        this._state = State.Uninitialized;
+        this.checkForUpdates(false);
+    }
+    async isLatestVersion() {
+        const update = await this.doCheckForUpdates(false);
+        if (update === undefined) {
+            return undefined;
+        }
+        return !!update;
+    }
+    async checkForUpdates(explicit) {
+        await this.doCheckForUpdates(explicit);
+    }
+    async doCheckForUpdates(explicit) {
+        if (this.environmentService.options && this.environmentService.options.updateProvider) {
+            const updateProvider = this.environmentService.options.updateProvider;
+            this.state = State.CheckingForUpdates(explicit);
+            const update = await updateProvider.checkForUpdate();
+            if (update) {
+                this.state = State.Ready({ version: update.version, productVersion: update.version });
+            }
+            else {
+                this.state = State.Idle(UpdateType.Archive);
+            }
+            return update;
+        }
+        return undefined;
+    }
+    async downloadUpdate() {
+    }
+    async applyUpdate() {
+        this.hostService.reload();
+    }
+    async quitAndInstall() {
+        this.hostService.reload();
+    }
+    async _applySpecificUpdate(packagePath) {
+    }
+};
+BrowserUpdateService = ( __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, IHostService))
+], BrowserUpdateService));
+
+export { BrowserUpdateService };