@codingame/monaco-vscode-edit-sessions-service-override 25.1.2 → 26.0.0

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

@@ -24,7 +24,7 @@ import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/fi
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { createCommandUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 
-const EDIT_SESSIONS_COUNT_KEY = 'editSessionsCount';
+const EDIT_SESSIONS_COUNT_KEY = "editSessionsCount";
 const EDIT_SESSIONS_COUNT_CONTEXT_KEY = ( new RawContextKey(EDIT_SESSIONS_COUNT_KEY, 0));
 let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
     constructor(container, instantiationService) {
@@ -40,22 +40,22 @@ let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
         treeView.dataProvider = this.instantiationService.createInstance(EditSessionDataViewDataProvider);
         const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
         viewsRegistry.registerViews([{
-                id: viewId,
-                name: EDIT_SESSIONS_TITLE,
-                ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
-                canToggleVisibility: true,
-                canMoveView: false,
-                treeView,
-                collapsed: false,
-                when: ( ContextKeyExpr.and(EDIT_SESSIONS_SHOW_VIEW)),
-                order: 100,
-                hideByDefault: true,
-            }], container);
+            id: viewId,
+            name: EDIT_SESSIONS_TITLE,
+            ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
+            canToggleVisibility: true,
+            canMoveView: false,
+            treeView,
+            collapsed: false,
+            when: ( ContextKeyExpr.and(EDIT_SESSIONS_SHOW_VIEW)),
+            order: 100,
+            hideByDefault: true
+        }], container);
         viewsRegistry.registerViewWelcomeContent(viewId, {
             content: ( localize(
-                7244,
-                'You have no stored changes in the cloud to display.\n{0}',
-                `[${( localize(7245, 'Store Working Changes'))}](${createCommandUri('workbench.editSessions.actions.store')})`
+                7555,
+                "You have no stored changes in the cloud to display.\n{0}",
+                `[${( localize(7556, "Store Working Changes"))}](${createCommandUri("workbench.editSessions.actions.store")})`
             )),
             when: ( ContextKeyExpr.equals(EDIT_SESSIONS_COUNT_KEY, 0)),
             order: 1
@@ -63,47 +63,47 @@ let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
         this._register(registerAction2(class extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.resume',
-                    title: ( localize(7246, "Resume Working Changes")),
+                    id: "workbench.editSessions.actions.resume",
+                    title: ( localize(7557, "Resume Working Changes")),
                     icon: Codicon.desktopDownload,
                     menu: {
                         id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /edit-session/i)))),
-                        group: 'inline'
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", viewId)), ( ContextKeyExpr.regex("viewItem", /edit-session/i)))),
+                        group: "inline"
                     }
                 });
             }
             async run(accessor, handle) {
                 const editSessionId = ( URI.parse(handle.$treeItemHandle)).path.substring(1);
                 const commandService = accessor.get(ICommandService);
-                await commandService.executeCommand('workbench.editSessions.actions.resumeLatest', editSessionId, true);
+                await commandService.executeCommand("workbench.editSessions.actions.resumeLatest", editSessionId, true);
                 await treeView.refresh();
             }
         }));
         this._register(registerAction2(class extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.store',
-                    title: ( localize(7247, "Store Working Changes")),
-                    icon: Codicon.cloudUpload,
+                    id: "workbench.editSessions.actions.store",
+                    title: ( localize(7558, "Store Working Changes")),
+                    icon: Codicon.cloudUpload
                 });
             }
             async run(accessor, handle) {
                 const commandService = accessor.get(ICommandService);
-                await commandService.executeCommand('workbench.editSessions.actions.storeCurrent');
+                await commandService.executeCommand("workbench.editSessions.actions.storeCurrent");
                 await treeView.refresh();
             }
         }));
         this._register(registerAction2(class extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.delete',
-                    title: ( localize(7248, "Delete Working Changes")),
+                    id: "workbench.editSessions.actions.delete",
+                    title: ( localize(7559, "Delete Working Changes")),
                     icon: Codicon.trash,
                     menu: {
                         id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /edit-session/i)))),
-                        group: 'inline'
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", viewId)), ( ContextKeyExpr.regex("viewItem", /edit-session/i)))),
+                        group: "inline"
                     }
                 });
             }
@@ -113,16 +113,16 @@ let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
                 const editSessionStorageService = accessor.get(IEditSessionsStorageService);
                 const result = await dialogService.confirm({
                     message: ( localize(
-                        7249,
-                        'Are you sure you want to permanently delete your working changes with ref {0}?',
+                        7560,
+                        "Are you sure you want to permanently delete your working changes with ref {0}?",
                         editSessionId
                     )),
-                    detail: ( localize(7250, ' You cannot undo this action.')),
-                    type: 'warning',
+                    detail: ( localize(7561, " You cannot undo this action.")),
+                    type: "warning",
                     title: EDIT_SESSIONS_TITLE.value
                 });
                 if (result.confirmed) {
-                    await editSessionStorageService.delete('editSessions', editSessionId);
+                    await editSessionStorageService.delete("editSessions", editSessionId);
                     await treeView.refresh();
                 }
             }
@@ -130,12 +130,12 @@ let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
         this._register(registerAction2(class extends Action2 {
             constructor() {
                 super({
-                    id: 'workbench.editSessions.actions.deleteAll',
-                    title: ( localize(7251, "Delete All Working Changes from Cloud")),
+                    id: "workbench.editSessions.actions.deleteAll",
+                    title: ( localize(7562, "Delete All Working Changes from Cloud")),
                     icon: Codicon.trash,
                     menu: {
                         id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ContextKeyExpr.greater(EDIT_SESSIONS_COUNT_KEY, 0))),
+                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", viewId)), ContextKeyExpr.greater(EDIT_SESSIONS_COUNT_KEY, 0)))
                     }
                 });
             }
@@ -144,26 +144,29 @@ let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
                 const editSessionStorageService = accessor.get(IEditSessionsStorageService);
                 const result = await dialogService.confirm({
                     message: ( localize(
-                        7252,
-                        'Are you sure you want to permanently delete all stored changes from the cloud?'
+                        7563,
+                        "Are you sure you want to permanently delete all stored changes from the cloud?"
                     )),
-                    detail: ( localize(7253, ' You cannot undo this action.')),
-                    type: 'warning',
+                    detail: ( localize(7564, " You cannot undo this action.")),
+                    type: "warning",
                     title: EDIT_SESSIONS_TITLE.value
                 });
                 if (result.confirmed) {
-                    await editSessionStorageService.delete('editSessions', null);
+                    await editSessionStorageService.delete("editSessions", null);
                     await treeView.refresh();
                 }
             }
         }));
     }
 };
-EditSessionsDataViews = ( __decorate([
-    ( __param(1, IInstantiationService))
-], EditSessionsDataViews));
+EditSessionsDataViews = ( __decorate([( __param(1, IInstantiationService))], EditSessionsDataViews));
 let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
-    constructor(editSessionsStorageService, contextKeyService, workspaceContextService, fileService) {
+    constructor(
+        editSessionsStorageService,
+        contextKeyService,
+        workspaceContextService,
+        fileService
+    ) {
         this.editSessionsStorageService = editSessionsStorageService;
         this.contextKeyService = contextKeyService;
         this.workspaceContextService = workspaceContextService;
@@ -174,36 +177,39 @@ let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
         if (!element) {
             return this.getAllEditSessions();
         }
-        const [ref, folderName, filePath] = ( URI.parse(element.handle)).path.substring(1).split('/');
+        const [ref, folderName, filePath] = ( URI.parse(element.handle)).path.substring(1).split("/");
         if (ref && !folderName) {
             return this.getEditSession(ref);
-        }
-        else if (ref && folderName && !filePath) {
+        } else if (ref && folderName && !filePath) {
             return this.getEditSessionFolderContents(ref, folderName);
         }
         return [];
     }
     async getAllEditSessions() {
-        const allEditSessions = await this.editSessionsStorageService.list('editSessions');
+        const allEditSessions = await this.editSessionsStorageService.list("editSessions");
         this.editSessionsCount.set(allEditSessions.length);
         const editSessions = [];
         for (const session of allEditSessions) {
-            const resource = ( URI.from(
-                { scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${session.ref}` }
-            ));
-            const sessionData = await this.editSessionsStorageService.read('editSessions', session.ref);
+            const resource = ( URI.from({
+                scheme: EDIT_SESSIONS_SCHEME,
+                authority: "remote-session-content",
+                path: `/${session.ref}`
+            }));
+            const sessionData = await this.editSessionsStorageService.read("editSessions", session.ref);
             if (!sessionData) {
                 continue;
             }
             const content = JSON.parse(sessionData.content);
-            const label = ( content.folders.map((folder) => folder.name)).join(', ') ?? session.ref;
+            const label = ( content.folders.map(folder => folder.name)).join(", ") ?? session.ref;
             const machineId = content.machine;
             const machineName = machineId ? await this.editSessionsStorageService.getMachineById(machineId) : undefined;
             const description = machineName === undefined ? fromNow(session.created, true) : `${fromNow(session.created, true)}\u00a0\u00a0\u2022\u00a0\u00a0${machineName}`;
             editSessions.push({
                 handle: ( resource.toString()),
                 collapsibleState: TreeItemCollapsibleState.Collapsed,
-                label: { label },
+                label: {
+                    label
+                },
                 description: description,
                 themeIcon: Codicon.repo,
                 contextValue: `edit-session`
@@ -212,7 +218,7 @@ let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
         return editSessions;
     }
     async getEditSession(ref) {
-        const data = await this.editSessionsStorageService.read('editSessions', ref);
+        const data = await this.editSessionsStorageService.read("editSessions", ref);
         if (!data) {
             return [];
         }
@@ -221,33 +227,39 @@ let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
             const folder = content.folders[0];
             return this.getEditSessionFolderContents(ref, folder.name);
         }
-        return ( content.folders.map((folder) => {
-            const resource = ( URI.from(
-                { scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${data.ref}/${folder.name}` }
-            ));
+        return ( content.folders.map(folder => {
+            const resource = ( URI.from({
+                scheme: EDIT_SESSIONS_SCHEME,
+                authority: "remote-session-content",
+                path: `/${data.ref}/${folder.name}`
+            }));
             return {
                 handle: ( resource.toString()),
                 collapsibleState: TreeItemCollapsibleState.Collapsed,
-                label: { label: folder.name },
+                label: {
+                    label: folder.name
+                },
                 themeIcon: Codicon.folder
             };
         }));
     }
     async getEditSessionFolderContents(ref, folderName) {
-        const data = await this.editSessionsStorageService.read('editSessions', ref);
+        const data = await this.editSessionsStorageService.read("editSessions", ref);
         if (!data) {
             return [];
         }
         const content = JSON.parse(data.content);
-        const currentWorkspaceFolder = this.workspaceContextService.getWorkspace().folders.find((folder) => folder.name === folderName);
-        const editSessionFolder = content.folders.find((folder) => folder.name === folderName);
+        const currentWorkspaceFolder = this.workspaceContextService.getWorkspace().folders.find(folder => folder.name === folderName);
+        const editSessionFolder = content.folders.find(folder => folder.name === folderName);
         if (!editSessionFolder) {
             return [];
         }
-        return Promise.all(( editSessionFolder.workingChanges.map(async (change) => {
-            const cloudChangeUri = ( URI.from(
-                { scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${data.ref}/${folderName}/${change.relativeFilePath}` }
-            ));
+        return Promise.all(( editSessionFolder.workingChanges.map(async change => {
+            const cloudChangeUri = ( URI.from({
+                scheme: EDIT_SESSIONS_SCHEME,
+                authority: "remote-session-content",
+                path: `/${data.ref}/${folderName}/${change.relativeFilePath}`
+            }));
             if (currentWorkspaceFolder?.uri) {
                 const localCopy = joinPath(currentWorkspaceFolder.uri, change.relativeFilePath);
                 if (change.type === ChangeType.Addition && (await this.fileService.exists(localCopy))) {
@@ -255,15 +267,17 @@ let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
                         handle: ( cloudChangeUri.toString()),
                         resourceUri: cloudChangeUri,
                         collapsibleState: TreeItemCollapsibleState.None,
-                        label: { label: change.relativeFilePath },
+                        label: {
+                            label: change.relativeFilePath
+                        },
                         themeIcon: Codicon.file,
                         command: {
-                            id: 'vscode.diff',
-                            title: ( localize(7254, 'Compare Changes')),
+                            id: "vscode.diff",
+                            title: ( localize(7565, "Compare Changes")),
                             arguments: [
                                 localCopy,
                                 cloudChangeUri,
-                                `${basename(change.relativeFilePath)} (${( localize(7255, 'Local Copy'))} \u2194 ${( localize(7256, 'Cloud Changes'))})`,
+                                `${basename(change.relativeFilePath)} (${( localize(7566, "Local Copy"))} \u2194 ${( localize(7567, "Cloud Changes"))})`,
                                 undefined
                             ]
                         }
@@ -274,22 +288,19 @@ let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
                 handle: ( cloudChangeUri.toString()),
                 resourceUri: cloudChangeUri,
                 collapsibleState: TreeItemCollapsibleState.None,
-                label: { label: change.relativeFilePath },
+                label: {
+                    label: change.relativeFilePath
+                },
                 themeIcon: Codicon.file,
                 command: {
                     id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: ( localize(7257, 'Open File')),
+                    title: ( localize(7568, "Open File")),
                     arguments: [cloudChangeUri, undefined, undefined]
                 }
             };
         })));
     }
 };
-EditSessionDataViewDataProvider = ( __decorate([
-    ( __param(0, IEditSessionsStorageService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IFileService))
-], EditSessionDataViewDataProvider));
+EditSessionDataViewDataProvider = ( __decorate([( __param(0, IEditSessionsStorageService)), ( __param(1, IContextKeyService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IFileService))], EditSessionDataViewDataProvider));
 
 export { EditSessionsDataViews };

package/vscode/src/vs/workbench/contrib/editSessions/common/editSessions.js

@@ -6,35 +6,35 @@ import { RawContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/c
 import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
 import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
 
-const EDIT_SESSION_SYNC_CATEGORY = ( localize2(7258, 'Cloud Changes'));
+const EDIT_SESSION_SYNC_CATEGORY = ( localize2(7569, "Cloud Changes"));
 var ChangeType;
-(function (ChangeType) {
+(function(ChangeType) {
     ChangeType[ChangeType["Addition"] = 1] = "Addition";
     ChangeType[ChangeType["Deletion"] = 2] = "Deletion";
 })(ChangeType || (ChangeType = {}));
 var FileType;
-(function (FileType) {
+(function(FileType) {
     FileType[FileType["File"] = 1] = "File";
 })(FileType || (FileType = {}));
 const EditSessionSchemaVersion = 3;
-const EDIT_SESSIONS_SIGNED_IN_KEY = 'editSessionsSignedIn';
+const EDIT_SESSIONS_SIGNED_IN_KEY = "editSessionsSignedIn";
 const EDIT_SESSIONS_SIGNED_IN = ( new RawContextKey(EDIT_SESSIONS_SIGNED_IN_KEY, false));
-const EDIT_SESSIONS_PENDING_KEY = 'editSessionsPending';
+const EDIT_SESSIONS_PENDING_KEY = "editSessionsPending";
 const EDIT_SESSIONS_PENDING = ( new RawContextKey(EDIT_SESSIONS_PENDING_KEY, false));
-const EDIT_SESSIONS_CONTAINER_ID = 'workbench.view.editSessions';
-const EDIT_SESSIONS_DATA_VIEW_ID = 'workbench.views.editSessions.data';
-const EDIT_SESSIONS_TITLE = ( localize2(7258, 'Cloud Changes'));
-const EDIT_SESSIONS_VIEW_ICON = registerIcon('edit-sessions-view-icon', Codicon.cloudDownload, ( localize(7259, 'View icon of the cloud changes view.')));
-const EDIT_SESSIONS_SHOW_VIEW = ( new RawContextKey('editSessionsShowView', false));
-const EDIT_SESSIONS_SCHEME = 'vscode-edit-sessions';
+const EDIT_SESSIONS_CONTAINER_ID = "workbench.view.editSessions";
+const EDIT_SESSIONS_DATA_VIEW_ID = "workbench.views.editSessions.data";
+const EDIT_SESSIONS_TITLE = ( localize2(7569, "Cloud Changes"));
+const EDIT_SESSIONS_VIEW_ICON = registerIcon("edit-sessions-view-icon", Codicon.cloudDownload, ( localize(7570, "View icon of the cloud changes view.")));
+const EDIT_SESSIONS_SHOW_VIEW = ( new RawContextKey("editSessionsShowView", false));
+const EDIT_SESSIONS_SCHEME = "vscode-edit-sessions";
 function decodeEditSessionFileContent(version, content) {
     switch (version) {
-        case 1:
-            return VSBuffer.fromString(content);
-        case 2:
-            return decodeBase64(content);
-        default:
-            throw ( new Error('Upgrade to a newer version to decode this content.'));
+    case 1:
+        return VSBuffer.fromString(content);
+    case 2:
+        return decodeBase64(content);
+    default:
+        throw ( new Error("Upgrade to a newer version to decode this content."));
     }
 }
 function hashedEditSessionId(editSessionId) {
@@ -42,6 +42,6 @@ function hashedEditSessionId(editSessionId) {
     sha1.update(editSessionId);
     return sha1.digest();
 }
-const editSessionsLogId = 'editSessions';
+const editSessionsLogId = "editSessions";
 
 export { ChangeType, EDIT_SESSIONS_CONTAINER_ID, EDIT_SESSIONS_DATA_VIEW_ID, EDIT_SESSIONS_PENDING, EDIT_SESSIONS_PENDING_KEY, EDIT_SESSIONS_SCHEME, EDIT_SESSIONS_SHOW_VIEW, EDIT_SESSIONS_SIGNED_IN, EDIT_SESSIONS_SIGNED_IN_KEY, EDIT_SESSIONS_TITLE, EDIT_SESSIONS_VIEW_ICON, EDIT_SESSION_SYNC_CATEGORY, EditSessionSchemaVersion, FileType, decodeEditSessionFileContent, editSessionsLogId, hashedEditSessionId };

package/vscode/src/vs/workbench/contrib/editSessions/common/editSessionsLogService.js

@@ -11,7 +11,13 @@ import { editSessionsLogId } from './editSessions.js';
 let EditSessionsLogService = class EditSessionsLogService extends AbstractLogger {
     constructor(loggerService, environmentService) {
         super();
-        this.logger = this._register(loggerService.createLogger(joinPath(environmentService.logsHome, `${editSessionsLogId}.log`), { id: editSessionsLogId, name: ( localize(7260, "Cloud Changes")), group: windowLogGroup }));
+        this.logger = this._register(
+            loggerService.createLogger(joinPath(environmentService.logsHome, `${editSessionsLogId}.log`), {
+                id: editSessionsLogId,
+                name: ( localize(7571, "Cloud Changes")),
+                group: windowLogGroup
+            })
+        );
     }
     trace(message, ...args) {
         this.logger.trace(message, ...args);
@@ -32,9 +38,6 @@ let EditSessionsLogService = class EditSessionsLogService extends AbstractLogger
         this.logger.flush();
     }
 };
-EditSessionsLogService = ( __decorate([
-    ( __param(0, ILoggerService)),
-    ( __param(1, IEnvironmentService))
-], EditSessionsLogService));
+EditSessionsLogService = ( __decorate([( __param(0, ILoggerService)), ( __param(1, IEnvironmentService))], EditSessionsLogService));
 
 export { EditSessionsLogService };

package/vscode/src/vs/workbench/contrib/editSessions/common/workspaceStateSync.js

@@ -33,19 +33,45 @@ class NullEnablementService {
         this._onDidChangeResourceEnablement = ( new Emitter());
         this.onDidChangeResourceEnablement = this._onDidChangeResourceEnablement.event;
     }
-    isEnabled() { return true; }
-    canToggleEnablement() { return true; }
-    setEnablement(_enabled) { }
-    isResourceEnabled(_resource) { return true; }
-    isResourceEnablementConfigured(_resource) { return false; }
-    setResourceEnablement(_resource, _enabled) { }
-    getResourceSyncStateVersion(_resource) { return undefined; }
+    isEnabled() {
+        return true;
+    }
+    canToggleEnablement() {
+        return true;
+    }
+    setEnablement(_enabled) {}
+    isResourceEnabled(_resource) {
+        return true;
+    }
+    isResourceEnablementConfigured(_resource) {
+        return false;
+    }
+    setResourceEnablement(_resource, _enabled) {}
+    getResourceSyncStateVersion(_resource) {
+        return undefined;
+    }
 }
 let WorkspaceStateSynchroniser = class WorkspaceStateSynchroniser extends AbstractSynchroniser {
-    constructor(profile, collection, userDataSyncStoreService, logService, fileService, environmentService, telemetryService, configurationService, storageService, uriIdentityService, workspaceIdentityService, editSessionsStorageService) {
+    constructor(
+        profile,
+        collection,
+        userDataSyncStoreService,
+        logService,
+        fileService,
+        environmentService,
+        telemetryService,
+        configurationService,
+        storageService,
+        uriIdentityService,
+        workspaceIdentityService,
+        editSessionsStorageService
+    ) {
         const userDataSyncLocalStoreService = ( new NullBackupStoreService());
         const userDataSyncEnablementService = ( new NullEnablementService());
-        super({ syncResource: SyncResource.WorkspaceState, profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
+        super({
+            syncResource: SyncResource.WorkspaceState,
+            profile
+        }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
         this.workspaceIdentityService = workspaceIdentityService;
         this.editSessionsStorageService = editSessionsStorageService;
         this.version = 1;
@@ -62,32 +88,40 @@ let WorkspaceStateSynchroniser = class WorkspaceStateSynchroniser extends Abstra
             return null;
         }
         const contributedData = {};
-        keys.forEach((key) => {
+        keys.forEach(key => {
             const data = this.storageService.get(key, StorageScope.WORKSPACE);
             if (data) {
                 contributedData[key] = data;
             }
         });
-        const content = { folders, storage: contributedData, version: this.version };
-        await this.editSessionsStorageService.write('workspaceState', stringify(content));
+        const content = {
+            folders,
+            storage: contributedData,
+            version: this.version
+        };
+        await this.editSessionsStorageService.write("workspaceState", stringify(content));
         return null;
     }
     async apply() {
-        const payload = this.editSessionsStorageService.lastReadResources.get('editSessions')?.content;
+        const payload = this.editSessionsStorageService.lastReadResources.get("editSessions")?.content;
         const workspaceStateId = payload ? JSON.parse(payload).workspaceStateId : undefined;
-        const resource = await this.editSessionsStorageService.read('workspaceState', workspaceStateId);
+        const resource = await this.editSessionsStorageService.read("workspaceState", workspaceStateId);
         if (!resource) {
             return null;
         }
         const remoteWorkspaceState = parse(resource.content);
         if (!remoteWorkspaceState) {
-            this.logService.info('Skipping initializing workspace state because remote workspace state does not exist.');
+            this.logService.info(
+                "Skipping initializing workspace state because remote workspace state does not exist."
+            );
             return null;
         }
         const cancellationTokenSource = ( new CancellationTokenSource());
         const replaceUris = await this.workspaceIdentityService.matches(remoteWorkspaceState.folders, cancellationTokenSource.token);
         if (!replaceUris) {
-            this.logService.info('Skipping initializing workspace state because remote workspace state does not match current workspace.');
+            this.logService.info(
+                "Skipping initializing workspace state because remote workspace state does not match current workspace."
+            );
             return null;
         }
         const storage = {};
@@ -100,28 +134,43 @@ let WorkspaceStateSynchroniser = class WorkspaceStateSynchroniser extends Abstra
                 try {
                     const value = parse(storage[key]);
                     replaceUris(value);
-                    storageEntries.push({ key, value, scope: StorageScope.WORKSPACE, target: StorageTarget.USER });
-                }
-                catch {
-                    storageEntries.push({ key, value: storage[key], scope: StorageScope.WORKSPACE, target: StorageTarget.USER });
+                    storageEntries.push({
+                        key,
+                        value,
+                        scope: StorageScope.WORKSPACE,
+                        target: StorageTarget.USER
+                    });
+                } catch {
+                    storageEntries.push({
+                        key,
+                        value: storage[key],
+                        scope: StorageScope.WORKSPACE,
+                        target: StorageTarget.USER
+                    });
                 }
             }
             this.storageService.storeAll(storageEntries, true);
         }
-        this.editSessionsStorageService.delete('workspaceState', resource.ref);
+        this.editSessionsStorageService.delete("workspaceState", resource.ref);
         return null;
     }
     applyResult(remoteUserData, lastSyncUserData, result, force) {
-        throw ( new Error('Method not implemented.'));
+        throw ( new Error("Method not implemented."));
     }
-    async generateSyncPreview(remoteUserData, lastSyncUserData, isRemoteDataFromCurrentMachine, userDataSyncConfiguration, token) {
+    async generateSyncPreview(
+        remoteUserData,
+        lastSyncUserData,
+        isRemoteDataFromCurrentMachine,
+        userDataSyncConfiguration,
+        token
+    ) {
         return [];
     }
     getMergeResult(resourcePreview, token) {
-        throw ( new Error('Method not implemented.'));
+        throw ( new Error("Method not implemented."));
     }
     getAcceptResult(resourcePreview, resource, content, token) {
-        throw ( new Error('Method not implemented.'));
+        throw ( new Error("Method not implemented."));
     }
     async hasRemoteChanged(lastSyncUserData) {
         return true;
@@ -133,15 +182,6 @@ let WorkspaceStateSynchroniser = class WorkspaceStateSynchroniser extends Abstra
         return null;
     }
 };
-WorkspaceStateSynchroniser = ( __decorate([
-    ( __param(4, IFileService)),
-    ( __param(5, IEnvironmentService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IStorageService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, IWorkspaceIdentityService)),
-    ( __param(11, IEditSessionsStorageService))
-], WorkspaceStateSynchroniser));
+WorkspaceStateSynchroniser = ( __decorate([( __param(4, IFileService)), ( __param(5, IEnvironmentService)), ( __param(6, ITelemetryService)), ( __param(7, IConfigurationService)), ( __param(8, IStorageService)), ( __param(9, IUriIdentityService)), ( __param(10, IWorkspaceIdentityService)), ( __param(11, IEditSessionsStorageService))], WorkspaceStateSynchroniser));
 
 export { WorkspaceStateSynchroniser };