@codingame/monaco-vscode-edit-sessions-service-override 2.2.0-next.1

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

@@ -0,0 +1,325 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { TreeView, TreeViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/treeView';
+import { Extensions, TreeItemCollapsibleState } from 'vscode/vscode/vs/workbench/common/views';
+import { EDIT_SESSIONS_TITLE, EDIT_SESSIONS_SHOW_VIEW, IEditSessionsStorageService, EDIT_SESSIONS_SCHEME, ChangeType, EDIT_SESSIONS_DATA_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { fromNow } from 'vscode/vscode/vs/base/common/date';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { API_OPEN_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
+import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { basename } from 'vscode/vscode/vs/base/common/path';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+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) {
+        super();
+        this.instantiationService = instantiationService;
+        this.registerViews(container);
+    }
+    registerViews(container) {
+        const viewId = EDIT_SESSIONS_DATA_VIEW_ID;
+        const treeView = this.instantiationService.createInstance(TreeView, viewId, EDIT_SESSIONS_TITLE.value);
+        treeView.showCollapseAllAction = true;
+        treeView.showRefreshAction = true;
+        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);
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.resume',
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'workbench.editSessions.actions.resume.v2',
+                        "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'
+                    }
+                });
+            }
+            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 treeView.refresh();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.store',
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'workbench.editSessions.actions.store.v2',
+                        "Store Working Changes"
+                    )),
+                    icon: Codicon.cloudUpload,
+                });
+            }
+            async run(accessor, handle) {
+                const commandService = accessor.get(ICommandService);
+                await commandService.executeCommand('workbench.editSessions.actions.storeCurrent');
+                await treeView.refresh();
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.delete',
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'workbench.editSessions.actions.delete.v2',
+                        "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'
+                    }
+                });
+            }
+            async run(accessor, handle) {
+                const editSessionId = ( URI.parse(handle.$treeItemHandle)).path.substring(1);
+                const dialogService = accessor.get(IDialogService);
+                const editSessionStorageService = accessor.get(IEditSessionsStorageService);
+                const result = await dialogService.confirm({
+                    message: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'confirm delete.v2',
+                        'Are you sure you want to permanently delete your working changes with ref {0}?',
+                        editSessionId
+                    )),
+                    detail: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'confirm delete detail.v2',
+                        ' You cannot undo this action.'
+                    )),
+                    type: 'warning',
+                    title: EDIT_SESSIONS_TITLE.value
+                });
+                if (result.confirmed) {
+                    await editSessionStorageService.delete('editSessions', editSessionId);
+                    await treeView.refresh();
+                }
+            }
+        });
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: 'workbench.editSessions.actions.deleteAll',
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'workbench.editSessions.actions.deleteAll',
+                        "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))),
+                    }
+                });
+            }
+            async run(accessor) {
+                const dialogService = accessor.get(IDialogService);
+                const editSessionStorageService = accessor.get(IEditSessionsStorageService);
+                const result = await dialogService.confirm({
+                    message: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'confirm delete all',
+                        'Are you sure you want to permanently delete all stored changes from the cloud?'
+                    )),
+                    detail: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'confirm delete all detail',
+                        ' You cannot undo this action.'
+                    )),
+                    type: 'warning',
+                    title: EDIT_SESSIONS_TITLE.value
+                });
+                if (result.confirmed) {
+                    await editSessionStorageService.delete('editSessions', null);
+                    await treeView.refresh();
+                }
+            }
+        });
+    }
+};
+EditSessionsDataViews = ( __decorate([
+    ( __param(1, IInstantiationService))
+], EditSessionsDataViews));
+let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
+    constructor(editSessionsStorageService, contextKeyService, workspaceContextService, fileService) {
+        this.editSessionsStorageService = editSessionsStorageService;
+        this.contextKeyService = contextKeyService;
+        this.workspaceContextService = workspaceContextService;
+        this.fileService = fileService;
+        this.editSessionsCount = EDIT_SESSIONS_COUNT_CONTEXT_KEY.bindTo(this.contextKeyService);
+    }
+    async getChildren(element) {
+        if (!element) {
+            return this.getAllEditSessions();
+        }
+        const [ref, folderName, filePath] = ( URI.parse(element.handle)).path.substring(1).split('/');
+        if (ref && !folderName) {
+            return this.getEditSession(ref);
+        }
+        else if (ref && folderName && !filePath) {
+            return this.getEditSessionFolderContents(ref, folderName);
+        }
+        return [];
+    }
+    async getAllEditSessions() {
+        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);
+            if (!sessionData) {
+                continue;
+            }
+            const content = JSON.parse(sessionData.content);
+            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 },
+                description: description,
+                themeIcon: Codicon.repo,
+                contextValue: `edit-session`
+            });
+        }
+        return editSessions;
+    }
+    async getEditSession(ref) {
+        const data = await this.editSessionsStorageService.read('editSessions', ref);
+        if (!data) {
+            return [];
+        }
+        const content = JSON.parse(data.content);
+        if (content.folders.length === 1) {
+            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 {
+                handle: ( resource.toString()),
+                collapsibleState: TreeItemCollapsibleState.Collapsed,
+                label: { label: folder.name },
+                themeIcon: Codicon.folder
+            };
+        }));
+    }
+    async getEditSessionFolderContents(ref, folderName) {
+        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);
+        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}` }
+            ));
+            if (currentWorkspaceFolder?.uri) {
+                const localCopy = joinPath(currentWorkspaceFolder.uri, change.relativeFilePath);
+                if (change.type === ChangeType.Addition && (await this.fileService.exists(localCopy))) {
+                    return {
+                        handle: ( cloudChangeUri.toString()),
+                        resourceUri: cloudChangeUri,
+                        collapsibleState: TreeItemCollapsibleState.None,
+                        label: { label: change.relativeFilePath },
+                        themeIcon: Codicon.file,
+                        command: {
+                            id: 'vscode.diff',
+                            title: ( localizeWithPath(
+                                'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                                'compare changes',
+                                'Compare Changes'
+                            )),
+                            arguments: [
+                                localCopy,
+                                cloudChangeUri,
+                                `${basename(change.relativeFilePath)} (${( localizeWithPath(
+                                    'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                                    'local copy',
+                                    'Local Copy'
+                                ))} \u2194 ${( localizeWithPath(
+                                    'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                                    'cloud changes',
+                                    'Cloud Changes'
+                                ))})`,
+                                undefined
+                            ]
+                        }
+                    };
+                }
+            }
+            return {
+                handle: ( cloudChangeUri.toString()),
+                resourceUri: cloudChangeUri,
+                collapsibleState: TreeItemCollapsibleState.None,
+                label: { label: change.relativeFilePath },
+                themeIcon: Codicon.file,
+                command: {
+                    id: API_OPEN_EDITOR_COMMAND_ID,
+                    title: ( localizeWithPath(
+                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
+                        'open file',
+                        'Open File'
+                    )),
+                    arguments: [cloudChangeUri, undefined, undefined]
+                }
+            };
+        })));
+    }
+};
+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/editSessionsLogService.js

@@ -0,0 +1,41 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { AbstractLogger, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
+import { editSessionsLogId } from 'vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions';
+
+let EditSessionsLogService = class EditSessionsLogService extends AbstractLogger {
+    constructor(loggerService, environmentService) {
+        super();
+        this.logger = this._register(loggerService.createLogger(joinPath(environmentService.logsHome, `${editSessionsLogId}.log`), { id: editSessionsLogId, name: ( localizeWithPath(
+            'vs/workbench/contrib/editSessions/common/editSessionsLogService',
+            'cloudChangesLog',
+            "Cloud Changes"
+        )) }));
+    }
+    trace(message, ...args) {
+        this.logger.trace(message, ...args);
+    }
+    debug(message, ...args) {
+        this.logger.debug(message, ...args);
+    }
+    info(message, ...args) {
+        this.logger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    flush() {
+        this.logger.flush();
+    }
+};
+EditSessionsLogService = ( __decorate([
+    ( __param(0, ILoggerService)),
+    ( __param(1, IEnvironmentService))
+], EditSessionsLogService));
+
+export { EditSessionsLogService };

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

@@ -0,0 +1,6 @@
+import { UserDataSyncStoreClient } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncStoreService';
+
+class EditSessionsStoreClient extends UserDataSyncStoreClient {
+}
+
+export { EditSessionsStoreClient };

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

@@ -0,0 +1,142 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { stringify, parse } from 'vscode/vscode/vs/base/common/marshalling';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { AbstractSynchroniser } from 'vscode/vscode/vs/platform/userDataSync/common/abstractSynchronizer';
+import { IEditSessionsStorageService } from 'vscode/vscode/vs/workbench/contrib/editSessions/common/editSessions';
+import { IWorkspaceIdentityService } from '../../../services/workspaces/common/workspaceIdentityService.js';
+
+class NullBackupStoreService {
+    async writeResource() {
+        return;
+    }
+    async getAllResourceRefs() {
+        return [];
+    }
+    async resolveResourceContent() {
+        return null;
+    }
+}
+class NullEnablementService {
+    constructor() {
+        this._onDidChangeEnablement = ( new Emitter());
+        this.onDidChangeEnablement = this._onDidChangeEnablement.event;
+        this._onDidChangeResourceEnablement = ( new Emitter());
+        this.onDidChangeResourceEnablement = this._onDidChangeResourceEnablement.event;
+    }
+    isEnabled() { return true; }
+    canToggleEnablement() { return true; }
+    setEnablement(_enabled) { }
+    isResourceEnabled(_resource) { return true; }
+    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) {
+        const userDataSyncLocalStoreService = ( new NullBackupStoreService());
+        const userDataSyncEnablementService = ( new NullEnablementService());
+        super({ syncResource: "workspaceState" , profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
+        this.workspaceIdentityService = workspaceIdentityService;
+        this.editSessionsStorageService = editSessionsStorageService;
+        this.version = 1;
+    }
+    async sync() {
+        const cancellationTokenSource = ( new CancellationTokenSource());
+        const folders = await this.workspaceIdentityService.getWorkspaceStateFolders(cancellationTokenSource.token);
+        if (!folders.length) {
+            return;
+        }
+        await this.storageService.flush();
+        const keys = ( this.storageService.keys(1, 0 ));
+        if (!keys.length) {
+            return;
+        }
+        const contributedData = {};
+        keys.forEach((key) => {
+            const data = this.storageService.get(key, 1 );
+            if (data) {
+                contributedData[key] = data;
+            }
+        });
+        const content = { folders, storage: contributedData, version: this.version };
+        await this.editSessionsStorageService.write('workspaceState', stringify(content));
+    }
+    async apply() {
+        const payload = this.editSessionsStorageService.lastReadResources.get('editSessions')?.content;
+        const workspaceStateId = payload ? JSON.parse(payload).workspaceStateId : undefined;
+        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.');
+            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.');
+            return null;
+        }
+        const storage = {};
+        for (const key of ( Object.keys(remoteWorkspaceState.storage))) {
+            storage[key] = remoteWorkspaceState.storage[key];
+        }
+        if (( Object.keys(storage)).length) {
+            const storageEntries = [];
+            for (const key of ( Object.keys(storage))) {
+                try {
+                    const value = parse(storage[key]);
+                    replaceUris(value);
+                    storageEntries.push({ key, value, scope: 1 , target: 0  });
+                }
+                catch {
+                    storageEntries.push({ key, value: storage[key], scope: 1 , target: 0  });
+                }
+            }
+            this.storageService.storeAll(storageEntries, true);
+        }
+        this.editSessionsStorageService.delete('workspaceState', resource.ref);
+        return null;
+    }
+    applyResult(remoteUserData, lastSyncUserData, result, force) {
+        throw new Error('Method not implemented.');
+    }
+    async generateSyncPreview(remoteUserData, lastSyncUserData, isRemoteDataFromCurrentMachine, userDataSyncConfiguration, token) {
+        return [];
+    }
+    getMergeResult(resourcePreview, token) {
+        throw new Error('Method not implemented.');
+    }
+    getAcceptResult(resourcePreview, resource, content, token) {
+        throw new Error('Method not implemented.');
+    }
+    async hasRemoteChanged(lastSyncUserData) {
+        return true;
+    }
+    async hasLocalData() {
+        return false;
+    }
+    async resolveContent(uri) {
+        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));
+
+export { WorkspaceStateSynchroniser };

package/vscode/src/vs/workbench/services/workspaces/common/workspaceIdentityService.js

@@ -0,0 +1,5 @@
+import { createDecorator } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+const IWorkspaceIdentityService = ( createDecorator('IWorkspaceIdentityService'));
+
+export { IWorkspaceIdentityService };