@codingame/monaco-vscode-edit-sessions-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessionsFileSystemProvider.d.ts

@@ -0,0 +1,24 @@
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { FileSystemProviderCapabilities, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IStat, IWatchOptions } from "vscode/vscode/vs/platform/files/common/files";
+import { IEditSessionsStorageService } from "vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions.service";
+export declare class EditSessionsFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+    private editSessionsStorageService;
+    static readonly SCHEMA = "vscode-edit-sessions";
+    constructor(editSessionsStorageService: IEditSessionsStorageService);
+    readonly capabilities: FileSystemProviderCapabilities;
+    readFile(resource: URI): Promise<Uint8Array>;
+    stat(resource: URI): Promise<IStat>;
+    readonly onDidChangeCapabilities: Event<any>;
+    readonly onDidChangeFile: Event<any>;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    mkdir(resource: URI): Promise<void>;
+    readdir(resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    writeFile(): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessionsFileSystemProvider.js

@@ -1,7 +1,8 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Event } from 'vscode/vscode/vs/base/common/event';
-import { FileSystemProviderErrorCode, FileType, FilePermission } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, FilePermission } from 'vscode/vscode/vs/platform/files/common/files';
 import { EDIT_SESSIONS_SCHEME, ChangeType, decodeEditSessionFileContent } from '../common/editSessions.js';
 import { IEditSessionsStorageService } from 'vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions.service';
 import { NotSupportedError } from 'vscode/vscode/vs/base/common/errors';
@@ -10,7 +11,7 @@ let EditSessionsFileSystemProvider = class EditSessionsFileSystemProvider {
     static { this.SCHEMA = EDIT_SESSIONS_SCHEME; }
     constructor(editSessionsStorageService) {
         this.editSessionsStorageService = editSessionsStorageService;
-        this.capabilities = 2048  + 2 ;
+        this.capabilities = FileSystemProviderCapabilities.Readonly + FileSystemProviderCapabilities.FileReadWrite;
         this.onDidChangeCapabilities = Event.None;
         this.onDidChangeFile = Event.None;
     }

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessionsStorageService.d.ts

@@ -0,0 +1,80 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import { IQuickInputService } from "vscode/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { IResourceRefHandle } from "vscode/vscode/vs/platform/userDataSync/common/userDataSync";
+import { IAuthenticationService } from "vscode/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { EditSession, SyncResource } from "../common/editSessions.js";
+import { IEditSessionsLogService } from "vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions.service";
+import { IEditSessionsStorageService } from "vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { EditSessionsStoreClient } from "../common/editSessionsStorageClient.js";
+import { ISecretStorageService } from "vscode/vscode/vs/platform/secrets/common/secrets.service";
+export declare class EditSessionsWorkbenchService extends Disposable implements IEditSessionsStorageService {
+    private readonly fileService;
+    private readonly storageService;
+    private readonly quickInputService;
+    private readonly authenticationService;
+    private readonly extensionService;
+    private readonly environmentService;
+    private readonly logService;
+    private readonly productService;
+    private readonly contextKeyService;
+    private readonly dialogService;
+    private readonly secretStorageService;
+    _serviceBrand: undefined;
+    readonly SIZE_LIMIT: number;
+    private serverConfiguration;
+    private machineClient;
+    private authenticationInfo;
+    private static CACHED_SESSION_STORAGE_KEY;
+    private initialized;
+    private readonly signedInContext;
+    get isSignedIn(): boolean;
+    private _didSignIn;
+    get onDidSignIn(): import("vscode/vscode/vs/base/common/event").Event<void>;
+    private _didSignOut;
+    get onDidSignOut(): import("vscode/vscode/vs/base/common/event").Event<void>;
+    private _lastWrittenResources;
+    get lastWrittenResources(): Map<SyncResource, {
+        ref: string;
+        content: string;
+    }>;
+    private _lastReadResources;
+    get lastReadResources(): Map<SyncResource, {
+        ref: string;
+        content: string;
+    }>;
+    storeClient: EditSessionsStoreClient | undefined;
+    constructor(fileService: IFileService, storageService: IStorageService, quickInputService: IQuickInputService, authenticationService: IAuthenticationService, extensionService: IExtensionService, environmentService: IEnvironmentService, logService: IEditSessionsLogService, productService: IProductService, contextKeyService: IContextKeyService, dialogService: IDialogService, secretStorageService: ISecretStorageService);
+    write(resource: SyncResource, content: string | EditSession): Promise<string>;
+    read(resource: SyncResource, ref: string | undefined): Promise<{
+        ref: string;
+        content: string;
+    } | undefined>;
+    delete(resource: SyncResource, ref: string | null): Promise<void>;
+    list(resource: SyncResource): Promise<IResourceRefHandle[]>;
+    initialize(reason: "read" | "write", silent?: boolean): Promise<boolean>;
+    private doInitialize;
+    private cachedMachines;
+    getMachineById(machineId: string): Promise<string | undefined>;
+    private getOrCreateCurrentMachineId;
+    private getAuthenticationSession;
+    private shouldAttemptEditSessionInit;
+    private getAccountPreference;
+    private createQuickpickItems;
+    private getAllSessions;
+    private getAuthenticationProviders;
+    private get existingSessionId();
+    private set existingSessionId(value);
+    private getExistingSession;
+    private onDidChangeStorage;
+    private clearAuthenticationPreference;
+    private onDidChangeSessions;
+    private registerSignInAction;
+    private registerResetAuthenticationAction;
+}

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessionsStorageService.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { localize } from 'vscode/vscode/vs/nls';
 import { registerAction2, Action2, MenuId, MenuRegistry } from 'vscode/vscode/vs/platform/actions/common/actions';
@@ -8,6 +9,7 @@ import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/commo
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { createSyncHeaders } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
 import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication.service';
@@ -16,9 +18,9 @@ import { EDIT_SESSIONS_SIGNED_IN, EDIT_SESSIONS_PENDING_KEY, EDIT_SESSIONS_SIGNE
 import { IEditSessionsLogService } from 'vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions.service';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { getCurrentAuthenticationSessionInfo } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
+import { getCurrentAuthenticationSessionInfo } from '@codingame/monaco-vscode-3607c442-ae7a-594b-b840-038378c24fef-common/vscode/vs/workbench/services/authentication/browser/authenticationService';
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { UserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
+import { UserDataSyncMachinesService } from '@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets.service';
@@ -58,12 +60,12 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         this.SIZE_LIMIT = Math.floor(1024 * 1024 * 1.9);
         this.serverConfiguration = this.productService['editSessions.store'];
         this.initialized = false;
-        this._didSignIn = ( (new Emitter()));
-        this._didSignOut = ( (new Emitter()));
-        this._lastWrittenResources = ( (new Map()));
-        this._lastReadResources = ( (new Map()));
+        this._didSignIn = ( new Emitter());
+        this._didSignOut = ( new Emitter());
+        this._lastWrittenResources = ( new Map());
+        this._lastReadResources = ( new Map());
         this._register(this.authenticationService.onDidChangeSessions((e) => this.onDidChangeSessions(e.event)));
-        this._register(this.storageService.onDidChangeValue(-1 , EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, this._register(( (new DisposableStore()))))(() => this.onDidChangeStorage()));
+        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, this._store)(() => this.onDidChangeStorage()));
         this.registerSignInAction();
         this.registerResetAuthenticationAction();
         this.signedInContext = EDIT_SESSIONS_SIGNED_IN.bindTo(this.contextKeyService);
@@ -72,7 +74,7 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     async write(resource, content) {
         await this.initialize('write', false);
         if (!this.initialized) {
-            throw ( (new Error('Please sign in to store your edit session.')));
+            throw ( new Error('Please sign in to store your edit session.'));
         }
         if (typeof content !== 'string' && content.machine === undefined) {
             content.machine = await this.getOrCreateCurrentMachineId();
@@ -85,7 +87,7 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     async read(resource, ref) {
         await this.initialize('read', false);
         if (!this.initialized) {
-            throw ( (new Error('Please sign in to apply your latest edit session.')));
+            throw ( new Error('Please sign in to apply your latest edit session.'));
         }
         let content;
         const headers = createSyncHeaders(generateUuid());
@@ -111,7 +113,7 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     async delete(resource, ref) {
         await this.initialize('write', false);
         if (!this.initialized) {
-            throw ( (new Error(`Unable to delete edit session with ref ${ref}.`)));
+            throw ( new Error(`Unable to delete edit session with ref ${ref}.`));
         }
         try {
             await this.storeClient?.deleteResource(resource, ref);
@@ -123,7 +125,7 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     async list(resource) {
         await this.initialize('read', false);
         if (!this.initialized) {
-            throw ( (new Error(`Unable to list edit sessions.`)));
+            throw ( new Error(`Unable to list edit sessions.`));
         }
         try {
             return this.storeClient?.getAllResourceRefs(resource) ?? [];
@@ -147,9 +149,9 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     async doInitialize(reason, silent) {
         await this.extensionService.whenInstalledExtensionsRegistered();
         if (!this.serverConfiguration?.url) {
-            throw ( (new Error(
+            throw ( new Error(
                 'Unable to initialize sessions sync as session sync preference is not configured in product.json.'
-            )));
+            ));
         }
         if (this.storeClient === undefined) {
             return false;
@@ -159,14 +161,14 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
             this.clearAuthenticationPreference();
         }));
         if (this.machineClient === undefined) {
-            this.machineClient = ( (new UserDataSyncMachinesService(
+            this.machineClient = ( new UserDataSyncMachinesService(
                 this.environmentService,
                 this.fileService,
                 this.storageService,
                 this.storeClient,
                 this.logService,
                 this.productService
-            )));
+            ));
         }
         if (this.authenticationInfo !== undefined) {
             return true;
@@ -182,7 +184,7 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         await this.initialize('read', false);
         if (!this.cachedMachines) {
             const machines = await this.machineClient.getMachines();
-            this.cachedMachines = machines.reduce((map, machine) => map.set(machine.id, machine.name), ( (new Map())));
+            this.cachedMachines = machines.reduce((map, machine) => map.set(machine.id, machine.name), ( new Map()));
         }
         return this.cachedMachines.get(machineId);
     }
@@ -226,49 +228,47 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         return undefined;
     }
     shouldAttemptEditSessionInit() {
-        return isWeb && this.storageService.isNew(-1 ) && this.storageService.isNew(1 );
+        return isWeb && this.storageService.isNew(StorageScope.APPLICATION) && this.storageService.isNew(StorageScope.WORKSPACE);
     }
     async getAccountPreference(reason) {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const quickpick = disposables.add(this.quickInputService.createQuickPick({ useSeparators: true }));
         quickpick.ok = false;
-        quickpick.placeholder = reason === 'read' ? ( localize(2398, "Select an account to restore your working changes from the cloud")) : ( localize(2399, "Select an account to store your working changes in the cloud"));
+        quickpick.placeholder = reason === 'read' ? ( localize(5691, "Select an account to restore your working changes from the cloud")) : ( localize(5692, "Select an account to store your working changes in the cloud"));
         quickpick.ignoreFocusOut = true;
         quickpick.items = await this.createQuickpickItems();
-        return (
-             (new Promise((resolve, reject) => {
-                disposables.add(quickpick.onDidHide((e) => {
-                    reject(( (new CancellationError())));
-                    disposables.dispose();
-                }));
-                disposables.add(quickpick.onDidAccept(async (e) => {
-                    const selection = quickpick.selectedItems[0];
-                    const session = 'provider' in selection ? { ...(await this.authenticationService.createSession(selection.provider.id, selection.provider.scopes)), providerId: selection.provider.id } : ('session' in selection ? selection.session : undefined);
-                    resolve(session);
-                    quickpick.hide();
-                }));
-                quickpick.show();
-            }))
-        );
+        return ( new Promise((resolve, reject) => {
+            disposables.add(quickpick.onDidHide((e) => {
+                reject(( new CancellationError()));
+                disposables.dispose();
+            }));
+            disposables.add(quickpick.onDidAccept(async (e) => {
+                const selection = quickpick.selectedItems[0];
+                const session = 'provider' in selection ? { ...(await this.authenticationService.createSession(selection.provider.id, selection.provider.scopes)), providerId: selection.provider.id } : ('session' in selection ? selection.session : undefined);
+                resolve(session);
+                quickpick.hide();
+            }));
+            quickpick.show();
+        }));
     }
     async createQuickpickItems() {
         const options = [];
-        options.push({ type: 'separator', label: ( localize(2400, "Signed In")) });
+        options.push({ type: 'separator', label: ( localize(5693, "Signed In")) });
         const sessions = await this.getAllSessions();
         options.push(...sessions);
-        options.push({ type: 'separator', label: ( localize(2401, "Others")) });
+        options.push({ type: 'separator', label: ( localize(5694, "Others")) });
         for (const authenticationProvider of (await this.getAuthenticationProviders())) {
-            const signedInForProvider = ( (sessions.some(account => account.session.providerId === authenticationProvider.id)));
+            const signedInForProvider = ( sessions.some(account => account.session.providerId === authenticationProvider.id));
             if (!signedInForProvider || this.authenticationService.getProvider(authenticationProvider.id).supportsMultipleAccounts) {
                 const providerName = this.authenticationService.getProvider(authenticationProvider.id).label;
-                options.push({ label: ( localize(2402, "Sign in with {0}", providerName)), provider: authenticationProvider });
+                options.push({ label: ( localize(5695, "Sign in with {0}", providerName)), provider: authenticationProvider });
             }
         }
         return options;
     }
     async getAllSessions() {
         const authenticationProviders = await this.getAuthenticationProviders();
-        const accounts = ( (new Map()));
+        const accounts = ( new Map());
         let currentSession;
         for (const provider of authenticationProviders) {
             const sessions = await this.authenticationService.getSessions(provider.id, provider.scopes);
@@ -287,32 +287,32 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         if (currentSession !== undefined) {
             accounts.set(currentSession.session.account.id, currentSession);
         }
-        return [...( (accounts.values()))].sort((a, b) => a.label.localeCompare(b.label));
+        return [...( accounts.values())].sort((a, b) => a.label.localeCompare(b.label));
     }
     async getAuthenticationProviders() {
         if (!this.serverConfiguration) {
-            throw ( (new Error(
+            throw ( new Error(
                 'Unable to get configured authentication providers as session sync preference is not configured in product.json.'
-            )));
+            ));
         }
         const authenticationProviders = this.serverConfiguration.authenticationProviders;
-        const configuredAuthenticationProviders = ( (Object.keys(authenticationProviders))).reduce((result, id) => {
+        const configuredAuthenticationProviders = ( Object.keys(authenticationProviders)).reduce((result, id) => {
             result.push({ id, scopes: authenticationProviders[id].scopes });
             return result;
         }, []);
         const availableAuthenticationProviders = this.authenticationService.declaredProviders;
-        return configuredAuthenticationProviders.filter(({ id }) => ( (availableAuthenticationProviders.some(provider => provider.id === id))));
+        return configuredAuthenticationProviders.filter(({ id }) => ( availableAuthenticationProviders.some(provider => provider.id === id)));
     }
     get existingSessionId() {
-        return this.storageService.get(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, -1 );
+        return this.storageService.get(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, StorageScope.APPLICATION);
     }
     set existingSessionId(sessionId) {
         this.logService.trace(`Saving authentication session preference for ID ${sessionId}.`);
         if (sessionId === undefined) {
-            this.storageService.remove(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, -1 );
+            this.storageService.remove(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, StorageScope.APPLICATION);
         }
         else {
-            this.storageService.store(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, sessionId, -1 , 1 );
+            this.storageService.store(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, sessionId, StorageScope.APPLICATION, StorageTarget.MACHINE);
         }
     }
     async getExistingSession() {
@@ -342,15 +342,12 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     registerSignInAction() {
         const that = this;
         const id = 'workbench.editSessions.actions.signIn';
-        const when = ( (ContextKeyExpr.and(
-             (ContextKeyExpr.equals(EDIT_SESSIONS_PENDING_KEY, false)),
-             (ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, false))
-        )));
+        const when = ( ContextKeyExpr.and(( ContextKeyExpr.equals(EDIT_SESSIONS_PENDING_KEY, false)), ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, false))));
         this._register(registerAction2(class ResetEditSessionAuthenticationAction extends Action2 {
             constructor() {
                 super({
                     id,
-                    title: ( localize(2403, 'Turn on Cloud Changes...')),
+                    title: ( localize(5696, 'Turn on Cloud Changes...')),
                     category: EDIT_SESSION_SYNC_CATEGORY,
                     precondition: when,
                     menu: [{
@@ -367,17 +364,14 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
                 return await that.initialize('write', false);
             }
         }));
-        this._register(( (MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+        this._register(( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
             group: '2_editSessions',
             command: {
                 id,
-                title: ( localize(2404, 'Turn on Cloud Changes... (1)')),
+                title: ( localize(5697, 'Turn on Cloud Changes... (1)')),
             },
-            when: ( (ContextKeyExpr.and(
-                 (ContextKeyExpr.equals(EDIT_SESSIONS_PENDING_KEY, true)),
-                 (ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, false))
-            )))
-        }))));
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(EDIT_SESSIONS_PENDING_KEY, true)), ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, false))))
+        })));
     }
     registerResetAuthenticationAction() {
         const that = this;
@@ -385,23 +379,23 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
             constructor() {
                 super({
                     id: 'workbench.editSessions.actions.resetAuth',
-                    title: ( localize(2405, 'Turn off Cloud Changes...')),
+                    title: ( localize(5698, 'Turn off Cloud Changes...')),
                     category: EDIT_SESSION_SYNC_CATEGORY,
-                    precondition: ( (ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true))),
+                    precondition: ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true)),
                     menu: [{
                             id: MenuId.CommandPalette,
                         },
                         {
                             id: MenuId.AccountsContext,
                             group: '2_editSessions',
-                            when: ( (ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true))),
+                            when: ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true)),
                         }]
                 });
             }
             async run() {
                 const result = await that.dialogService.confirm({
-                    message: ( localize(2406, 'Do you want to disable storing working changes in the cloud?')),
-                    checkbox: { label: ( localize(2407, 'Delete all stored data from the cloud.')) }
+                    message: ( localize(5699, 'Do you want to disable storing working changes in the cloud?')),
+                    checkbox: { label: ( localize(5700, 'Delete all stored data from the cloud.')) }
                 });
                 if (result.confirmed) {
                     if (result.checkboxChecked) {
@@ -413,18 +407,18 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         }));
     }
 };
-EditSessionsWorkbenchService = EditSessionsWorkbenchService_1 = ( (__decorate([
-    ( (__param(0, IFileService))),
-    ( (__param(1, IStorageService))),
-    ( (__param(2, IQuickInputService))),
-    ( (__param(3, IAuthenticationService))),
-    ( (__param(4, IExtensionService))),
-    ( (__param(5, IEnvironmentService))),
-    ( (__param(6, IEditSessionsLogService))),
-    ( (__param(7, IProductService))),
-    ( (__param(8, IContextKeyService))),
-    ( (__param(9, IDialogService))),
-    ( (__param(10, ISecretStorageService)))
-], EditSessionsWorkbenchService)));
+EditSessionsWorkbenchService = EditSessionsWorkbenchService_1 = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IQuickInputService)),
+    ( __param(3, IAuthenticationService)),
+    ( __param(4, IExtensionService)),
+    ( __param(5, IEnvironmentService)),
+    ( __param(6, IEditSessionsLogService)),
+    ( __param(7, IProductService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IDialogService)),
+    ( __param(10, ISecretStorageService))
+], EditSessionsWorkbenchService));
 
 export { EditSessionsWorkbenchService };

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessionsViews.d.ts

@@ -0,0 +1,8 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { ViewContainer } from "vscode/vscode/vs/workbench/common/views";
+export declare class EditSessionsDataViews extends Disposable {
+    private readonly instantiationService;
+    constructor(container: ViewContainer, instantiationService: IInstantiationService);
+    private registerViews;
+}