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

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

@@ -8,7 +8,9 @@ import { IEditSessionsStorageService } from '@codingame/monaco-vscode-api/vscode
 import { NotSupportedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 
 let EditSessionsFileSystemProvider = class EditSessionsFileSystemProvider {
-    static { this.SCHEMA = EDIT_SESSIONS_SCHEME; }
+    static {
+        this.SCHEMA = EDIT_SESSIONS_SCHEME;
+    }
     constructor(editSessionsStorageService) {
         this.editSessionsStorageService = editSessionsStorageService;
         this.capabilities = FileSystemProviderCapabilities.Readonly + FileSystemProviderCapabilities.FileReadWrite;
@@ -20,13 +22,17 @@ let EditSessionsFileSystemProvider = class EditSessionsFileSystemProvider {
         if (!match?.groups) {
             throw FileSystemProviderErrorCode.FileNotFound;
         }
-        const { ref, folderName, filePath } = match.groups;
-        const data = await this.editSessionsStorageService.read('editSessions', ref);
+        const {
+            ref,
+            folderName,
+            filePath
+        } = match.groups;
+        const data = await this.editSessionsStorageService.read("editSessions", ref);
         if (!data) {
             throw FileSystemProviderErrorCode.FileNotFound;
         }
         const content = JSON.parse(data.content);
-        const change = content.folders.find((f) => f.name === folderName)?.workingChanges.find((change) => change.relativeFilePath === filePath);
+        const change = content.folders.find(f => f.name === folderName)?.workingChanges.find(change => change.relativeFilePath === filePath);
         if (!change || change.type === ChangeType.Deletion) {
             throw FileSystemProviderErrorCode.FileNotFound;
         }
@@ -43,17 +49,19 @@ let EditSessionsFileSystemProvider = class EditSessionsFileSystemProvider {
             size: content.byteLength
         };
     }
-    watch(resource, opts) { return Disposable.None; }
-    async mkdir(resource) { }
-    async readdir(resource) { return []; }
-    async rename(from, to, opts) { }
-    async delete(resource, opts) { }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    async mkdir(resource) {}
+    async readdir(resource) {
+        return [];
+    }
+    async rename(from, to, opts) {}
+    async delete(resource, opts) {}
     async writeFile() {
         throw ( new NotSupportedError());
     }
 };
-EditSessionsFileSystemProvider = ( __decorate([
-    ( __param(0, IEditSessionsStorageService))
-], EditSessionsFileSystemProvider));
+EditSessionsFileSystemProvider = ( __decorate([( __param(0, IEditSessionsStorageService))], EditSessionsFileSystemProvider));
 
 export { EditSessionsFileSystemProvider };

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

@@ -27,8 +27,12 @@ import { ISecretStorageService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 
 var EditSessionsWorkbenchService_1;
 let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Disposable {
-    static { EditSessionsWorkbenchService_1 = this; }
-    static { this.CACHED_SESSION_STORAGE_KEY = 'editSessionAccountPreference'; }
+    static {
+        EditSessionsWorkbenchService_1 = this;
+    }
+    static {
+        this.CACHED_SESSION_STORAGE_KEY = "editSessionAccountPreference";
+    }
     get isSignedIn() {
         return this.existingSessionId !== undefined;
     }
@@ -44,7 +48,19 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     get lastReadResources() {
         return this._lastReadResources;
     }
-    constructor(fileService, storageService, quickInputService, authenticationService, extensionService, environmentService, logService, productService, contextKeyService, dialogService, secretStorageService) {
+    constructor(
+        fileService,
+        storageService,
+        quickInputService,
+        authenticationService,
+        extensionService,
+        environmentService,
+        logService,
+        productService,
+        contextKeyService,
+        dialogService,
+        secretStorageService
+    ) {
         super();
         this.fileService = fileService;
         this.storageService = storageService;
@@ -63,74 +79,85 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         this._didSignOut = ( new Emitter());
         this._lastWrittenResources = ( new Map());
         this._lastReadResources = ( new Map());
-        this.serverConfiguration = this.productService['editSessions.store'];
-        this._register(this.authenticationService.onDidChangeSessions((e) => this.onDidChangeSessions(e.event)));
-        this._register(this.storageService.onDidChangeValue(StorageScope.APPLICATION, EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, this._store)(() => this.onDidChangeStorage()));
+        this.serverConfiguration = this.productService["editSessions.store"];
+        this._register(
+            this.authenticationService.onDidChangeSessions(e => this.onDidChangeSessions(e.event))
+        );
+        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);
         this.signedInContext.set(this.existingSessionId !== undefined);
     }
     async write(resource, content) {
-        await this.initialize('write', false);
+        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) {
+        if (typeof content !== "string" && content.machine === undefined) {
             content.machine = await this.getOrCreateCurrentMachineId();
         }
-        content = typeof content === 'string' ? content : JSON.stringify(content);
+        content = typeof content === "string" ? content : JSON.stringify(content);
         const ref = await this.storeClient.writeResource(resource, content, null, undefined, createSyncHeaders(generateUuid()));
-        this._lastWrittenResources.set(resource, { ref, content });
+        this._lastWrittenResources.set(resource, {
+            ref,
+            content
+        });
         return ref;
     }
     async read(resource, ref) {
-        await this.initialize('read', false);
+        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());
         try {
             if (ref !== undefined) {
                 content = await this.storeClient?.resolveResourceContent(resource, ref, undefined, headers);
-            }
-            else {
+            } else {
                 const result = await this.storeClient?.readResource(resource, null, undefined, headers);
                 content = result?.content;
                 ref = result?.ref;
             }
-        }
-        catch (ex) {
+        } catch (ex) {
             this.logService.error(ex);
         }
         if (content !== undefined && content !== null && ref !== undefined) {
-            this._lastReadResources.set(resource, { ref, content });
-            return { ref, content };
+            this._lastReadResources.set(resource, {
+                ref,
+                content
+            });
+            return {
+                ref,
+                content
+            };
         }
         return undefined;
     }
     async delete(resource, ref) {
-        await this.initialize('write', false);
+        await this.initialize("write", false);
         if (!this.initialized) {
             throw ( new Error(`Unable to delete edit session with ref ${ref}.`));
         }
         try {
             await this.storeClient?.deleteResource(resource, ref);
-        }
-        catch (ex) {
+        } catch (ex) {
             this.logService.error(ex);
         }
     }
     async list(resource) {
-        await this.initialize('read', false);
+        await this.initialize("read", false);
         if (!this.initialized) {
             throw ( new Error(`Unable to list edit sessions.`));
         }
         try {
             return this.storeClient?.getAllResourceRefs(resource) ?? [];
-        }
-        catch (ex) {
+        } catch (ex) {
             this.logService.error(ex);
         }
         return [];
@@ -150,14 +177,16 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         await this.extensionService.whenInstalledExtensionsRegistered();
         if (!this.serverConfiguration?.url) {
             throw ( new Error(
-                'Unable to initialize sessions sync as session sync preference is not configured in product.json.'
+                "Unable to initialize sessions sync as session sync preference is not configured in product.json."
             ));
         }
         if (this.storeClient === undefined) {
             return false;
         }
         this._register(this.storeClient.onTokenFailed(() => {
-            this.logService.info('Clearing edit sessions authentication preference because of successive token failures.');
+            this.logService.info(
+                "Clearing edit sessions authentication preference because of successive token failures."
+            );
             this.clearAuthenticationPreference();
         }));
         if (this.machineClient === undefined) {
@@ -181,7 +210,7 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         return authenticationSession !== undefined;
     }
     async getMachineById(machineId) {
-        await this.initialize('read', false);
+        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()));
@@ -189,22 +218,29 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         return this.cachedMachines.get(machineId);
     }
     async getOrCreateCurrentMachineId() {
-        const currentMachineId = await this.machineClient.getMachines().then((machines) => machines.find((m) => m.isCurrent)?.id);
+        const currentMachineId = await this.machineClient.getMachines().then(machines => machines.find(m => m.isCurrent)?.id);
         if (currentMachineId === undefined) {
             await this.machineClient.addCurrentMachine();
-            return await this.machineClient.getMachines().then((machines) => machines.find((m) => m.isCurrent).id);
+            return await this.machineClient.getMachines().then(machines => machines.find(m => m.isCurrent).id);
         }
         return currentMachineId;
     }
     async getAuthenticationSession(reason, silent) {
         if (this.existingSessionId) {
-            this.logService.info(`Searching for existing authentication session with ID ${this.existingSessionId}`);
+            this.logService.info(
+                `Searching for existing authentication session with ID ${this.existingSessionId}`
+            );
             const existingSession = await this.getExistingSession();
             if (existingSession) {
-                this.logService.info(`Found existing authentication session with ID ${existingSession.session.id}`);
-                return { sessionId: existingSession.session.id, token: existingSession.session.idToken ?? existingSession.session.accessToken, providerId: existingSession.session.providerId };
-            }
-            else {
+                this.logService.info(
+                    `Found existing authentication session with ID ${existingSession.session.id}`
+                );
+                return {
+                    sessionId: existingSession.session.id,
+                    token: existingSession.session.idToken ?? existingSession.session.accessToken,
+                    providerId: existingSession.session.providerId
+                };
+            } else {
                 this._didSignOut.fire();
             }
         }
@@ -212,9 +248,15 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
             this.logService.info(`Reusing user data sync enablement`);
             const authenticationSessionInfo = await getCurrentAuthenticationSessionInfo(this.secretStorageService, this.productService);
             if (authenticationSessionInfo !== undefined) {
-                this.logService.info(`Using current authentication session with ID ${authenticationSessionInfo.id}`);
+                this.logService.info(
+                    `Using current authentication session with ID ${authenticationSessionInfo.id}`
+                );
                 this.existingSessionId = authenticationSessionInfo.id;
-                return { sessionId: authenticationSessionInfo.id, token: authenticationSessionInfo.accessToken, providerId: authenticationSessionInfo.providerId };
+                return {
+                    sessionId: authenticationSessionInfo.id,
+                    token: authenticationSessionInfo.accessToken,
+                    providerId: authenticationSessionInfo.providerId
+                };
             }
         }
         if (silent) {
@@ -223,7 +265,11 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
         const authenticationSession = await this.getAccountPreference(reason);
         if (authenticationSession !== undefined) {
             this.existingSessionId = authenticationSession.id;
-            return { sessionId: authenticationSession.id, token: authenticationSession.idToken ?? authenticationSession.accessToken, providerId: authenticationSession.providerId };
+            return {
+                sessionId: authenticationSession.id,
+                token: authenticationSession.idToken ?? authenticationSession.accessToken,
+                providerId: authenticationSession.providerId
+            };
         }
         return undefined;
     }
@@ -232,19 +278,24 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     }
     async getAccountPreference(reason) {
         const disposables = ( new DisposableStore());
-        const quickpick = disposables.add(this.quickInputService.createQuickPick({ useSeparators: true }));
+        const quickpick = disposables.add(this.quickInputService.createQuickPick({
+            useSeparators: true
+        }));
         quickpick.ok = false;
-        quickpick.placeholder = reason === 'read' ? ( localize(7234, "Select an account to restore your working changes from the cloud")) : ( localize(7235, "Select an account to store your working changes in the cloud"));
+        quickpick.placeholder = reason === "read" ? ( localize(7545, "Select an account to restore your working changes from the cloud")) : ( localize(7546, "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) => {
+            disposables.add(quickpick.onDidHide(e => {
                 reject(( new CancellationError()));
                 disposables.dispose();
             }));
-            disposables.add(quickpick.onDidAccept(async (e) => {
+            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);
+                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();
             }));
@@ -253,15 +304,24 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     }
     async createQuickpickItems() {
         const options = [];
-        options.push({ type: 'separator', label: ( localize(7236, "Signed In")) });
+        options.push({
+            type: "separator",
+            label: ( localize(7547, "Signed In"))
+        });
         const sessions = await this.getAllSessions();
         options.push(...sessions);
-        options.push({ type: 'separator', label: ( localize(7237, "Others")) });
+        options.push({
+            type: "separator",
+            label: ( localize(7548, "Others"))
+        });
         for (const authenticationProvider of (await this.getAuthenticationProviders())) {
             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(7238, "Sign in with {0}", providerName)), provider: authenticationProvider });
+                options.push({
+                    label: ( localize(7549, "Sign in with {0}", providerName)),
+                    provider: authenticationProvider
+                });
             }
         }
         return options;
@@ -276,7 +336,10 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
                 const item = {
                     label: session.account.label,
                     description: this.authenticationService.getProvider(provider.id).label,
-                    session: { ...session, providerId: provider.id }
+                    session: {
+                        ...session,
+                        providerId: provider.id
+                    }
                 };
                 accounts.set(item.session.account.id, item);
                 if (this.existingSessionId === session.id) {
@@ -292,38 +355,57 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
     async getAuthenticationProviders() {
         if (!this.serverConfiguration) {
             throw ( new Error(
-                'Unable to get configured authentication providers as session sync preference is not configured in product.json.'
+                "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) => {
-            result.push({ id, scopes: authenticationProviders[id].scopes });
+            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, StorageScope.APPLICATION);
+        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, StorageScope.APPLICATION);
-        }
-        else {
-            this.storageService.store(EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY, sessionId, StorageScope.APPLICATION, StorageTarget.MACHINE);
+            this.storageService.remove(
+                EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY,
+                StorageScope.APPLICATION
+            );
+        } else {
+            this.storageService.store(
+                EditSessionsWorkbenchService_1.CACHED_SESSION_STORAGE_KEY,
+                sessionId,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
         }
     }
     async getExistingSession() {
         const accounts = await this.getAllSessions();
-        return accounts.find((account) => account.session.id === this.existingSessionId);
+        return accounts.find(account => account.session.id === this.existingSessionId);
     }
     async onDidChangeStorage() {
         const newSessionId = this.existingSessionId;
         const previousSessionId = this.authenticationInfo?.sessionId;
         if (previousSessionId !== newSessionId) {
-            this.logService.trace(`Resetting authentication state because authentication session ID preference changed from ${previousSessionId} to ${newSessionId}.`);
+            this.logService.trace(
+                `Resetting authentication state because authentication session ID preference changed from ${previousSessionId} to ${newSessionId}.`
+            );
             this.authenticationInfo = undefined;
             this.initialized = false;
         }
@@ -344,84 +426,76 @@ let EditSessionsWorkbenchService = class EditSessionsWorkbenchService extends Di
             return;
         }
         const that = this;
-        const id = 'workbench.editSessions.actions.signIn';
+        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))));
-        this._register(registerAction2(class ResetEditSessionAuthenticationAction extends Action2 {
-            constructor() {
-                super({
-                    id,
-                    title: ( localize(7239, 'Turn on Cloud Changes...')),
-                    category: EDIT_SESSION_SYNC_CATEGORY,
-                    precondition: when,
-                    menu: [{
-                            id: MenuId.CommandPalette,
-                        },
-                        {
+        this._register(
+            registerAction2(class ResetEditSessionAuthenticationAction extends Action2 {
+                constructor() {
+                    super({
+                        id,
+                        title: ( localize(7550, "Turn on Cloud Changes...")),
+                        category: EDIT_SESSION_SYNC_CATEGORY,
+                        precondition: when,
+                        menu: [{
+                            id: MenuId.CommandPalette
+                        }, {
                             id: MenuId.AccountsContext,
-                            group: '2_editSessions',
-                            when,
+                            group: "2_editSessions",
+                            when
                         }]
-                });
-            }
-            async run() {
-                return await that.initialize('write', false);
-            }
-        }));
+                    });
+                }
+                async run() {
+                    return await that.initialize("write", false);
+                }
+            })
+        );
         this._register(( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-            group: '2_editSessions',
+            group: "2_editSessions",
             command: {
                 id,
-                title: ( localize(7240, 'Turn on Cloud Changes... (1)')),
+                title: ( localize(7551, "Turn on Cloud Changes... (1)"))
             },
             when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(EDIT_SESSIONS_PENDING_KEY, true)), ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, false))))
         })));
     }
     registerResetAuthenticationAction() {
         const that = this;
-        this._register(registerAction2(class ResetEditSessionAuthenticationAction extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.editSessions.actions.resetAuth',
-                    title: ( localize(7241, 'Turn off Cloud Changes...')),
-                    category: EDIT_SESSION_SYNC_CATEGORY,
-                    precondition: ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true)),
-                    menu: [{
-                            id: MenuId.CommandPalette,
-                        },
-                        {
+        this._register(
+            registerAction2(class ResetEditSessionAuthenticationAction extends Action2 {
+                constructor() {
+                    super({
+                        id: "workbench.editSessions.actions.resetAuth",
+                        title: ( localize(7552, "Turn off Cloud Changes...")),
+                        category: EDIT_SESSION_SYNC_CATEGORY,
+                        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)),
+                            group: "2_editSessions",
+                            when: ( ContextKeyExpr.equals(EDIT_SESSIONS_SIGNED_IN_KEY, true))
                         }]
-                });
-            }
-            async run() {
-                const result = await that.dialogService.confirm({
-                    message: ( localize(7242, 'Do you want to disable storing working changes in the cloud?')),
-                    checkbox: { label: ( localize(7243, 'Delete all stored data from the cloud.')) }
-                });
-                if (result.confirmed) {
-                    if (result.checkboxChecked) {
-                        that.storeClient?.deleteResource('editSessions', null);
+                    });
+                }
+                async run() {
+                    const result = await that.dialogService.confirm({
+                        message: ( localize(7553, "Do you want to disable storing working changes in the cloud?")),
+                        checkbox: {
+                            label: ( localize(7554, "Delete all stored data from the cloud."))
+                        }
+                    });
+                    if (result.confirmed) {
+                        if (result.checkboxChecked) {
+                            that.storeClient?.deleteResource("editSessions", null);
+                        }
+                        that.clearAuthenticationPreference();
                     }
-                    that.clearAuthenticationPreference();
                 }
-            }
-        }));
+            })
+        );
     }
 };
-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 };