@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSyncViews.js

@@ -1,858 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { TreeItemCollapsibleState, Extensions } from '../../../common/views.js';
-import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { TreeView, TreeViewPane } from '../../../browser/parts/views/treeView.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IUserDataSyncService, IUserDataSyncEnablementService, IUserDataSyncResourceProviderService, IUserDataAutoSyncService, ALL_SYNC_RESOURCES, getLastSyncResourceUri, UserDataSyncError } from '../../../../platform/userDataSync/common/userDataSync.js';
-import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
-import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
-import { URI } from '../../../../base/common/uri.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { FolderThemeIcon } from '../../../../platform/theme/common/themeService.js';
-import { fromNow } from '../../../../base/common/date.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { Event } from '../../../../base/common/event.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { Action } from '../../../../base/common/actions.js';
-import { SYNC_CONFLICTS_VIEW_ID, CONTEXT_ENABLE_SYNC_CONFLICTS_VIEW, CONTEXT_HAS_CONFLICTS, CONTEXT_SYNC_STATE, CONTEXT_ACCOUNT_STATE, CONTEXT_ENABLE_ACTIVITY_VIEWS, getSyncAreaLabel, SYNC_TITLE, IUserDataSyncWorkbenchService } from '../../../services/userDataSync/common/userDataSync.js';
-import { IUserDataSyncMachinesService, isWebPlatform } from '../../../../platform/userDataSync/common/userDataSyncMachines.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { INotificationService, Severity } from '../../../../platform/notification/common/notification.js';
-import { basename } from '../../../../base/common/resources.js';
-import { API_OPEN_DIFF_EDITOR_COMMAND_ID, API_OPEN_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
-import { UserDataSyncConflictsViewPane } from './userDataSyncConflictsView.js';
-import { IFileDialogService, IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-let UserDataSyncDataViews = class UserDataSyncDataViews extends Disposable {
-    constructor(container, instantiationService, userDataSyncEnablementService, userDataSyncMachinesService, userDataSyncService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this.userDataSyncMachinesService = userDataSyncMachinesService;
-        this.userDataSyncService = userDataSyncService;
-        this.registerViews(container);
-    }
-    registerViews(container) {
-        this.registerConflictsView(container);
-        this.registerActivityView(container, true);
-        this.registerMachinesView(container);
-        this.registerActivityView(container, false);
-        this.registerTroubleShootView(container);
-        this.registerExternalActivityView(container);
-    }
-    registerConflictsView(container) {
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        const viewName = ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'conflicts',
-            "Conflicts"
-        ));
-        viewsRegistry.registerViews([{
-                id: SYNC_CONFLICTS_VIEW_ID,
-                name: viewName,
-                ctorDescriptor: ( new SyncDescriptor(UserDataSyncConflictsViewPane)),
-                when: ( ContextKeyExpr.and(CONTEXT_ENABLE_SYNC_CONFLICTS_VIEW, CONTEXT_HAS_CONFLICTS)),
-                canToggleVisibility: false,
-                canMoveView: false,
-                treeView: this.instantiationService.createInstance(TreeView, SYNC_CONFLICTS_VIEW_ID, viewName.value),
-                collapsed: false,
-                order: 100,
-            }], container);
-    }
-    registerMachinesView(container) {
-        const id = `workbench.views.sync.machines`;
-        const name = ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'synced machines',
-            "Synced Machines"
-        ));
-        const treeView = this.instantiationService.createInstance(TreeView, id, name.value);
-        const dataProvider = this.instantiationService.createInstance(UserDataSyncMachinesViewDataProvider, treeView);
-        treeView.showRefreshAction = true;
-        treeView.canSelectMany = true;
-        treeView.dataProvider = dataProvider;
-        this._register(Event.any(this.userDataSyncMachinesService.onDidChange, this.userDataSyncService.onDidResetRemote)(() => treeView.refresh()));
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        viewsRegistry.registerViews([{
-                id,
-                name,
-                ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
-                when: ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), ( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), CONTEXT_ENABLE_ACTIVITY_VIEWS)),
-                canToggleVisibility: true,
-                canMoveView: false,
-                treeView,
-                collapsed: false,
-                order: 300,
-            }], container);
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.actions.sync.editMachineName`,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'workbench.actions.sync.editMachineName',
-                        "Edit Name"
-                    )),
-                    icon: Codicon.edit,
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', id)))),
-                        group: 'inline',
-                    },
-                });
-            }
-            async run(accessor, handle) {
-                const changed = await dataProvider.rename(handle.$treeItemHandle);
-                if (changed) {
-                    await treeView.refresh();
-                }
-            }
-        }));
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.actions.sync.turnOffSyncOnMachine`,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'workbench.actions.sync.turnOffSyncOnMachine',
-                        "Turn off Settings Sync"
-                    )),
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', id)), ( ContextKeyExpr.equals('viewItem', 'sync-machine')))),
-                    },
-                });
-            }
-            async run(accessor, handle, selected) {
-                if (await dataProvider.disable(( (selected || [handle]).map(handle => handle.$treeItemHandle)))) {
-                    await treeView.refresh();
-                }
-            }
-        }));
-    }
-    registerActivityView(container, remote) {
-        const id = `workbench.views.sync.${remote ? 'remote' : 'local'}Activity`;
-        const name = remote ? ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'remote sync activity title',
-            "Sync Activity (Remote)"
-        )) : ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'local sync activity title',
-            "Sync Activity (Local)"
-        ));
-        const treeView = this.instantiationService.createInstance(TreeView, id, name.value);
-        treeView.showCollapseAllAction = true;
-        treeView.showRefreshAction = true;
-        treeView.dataProvider = remote ? this.instantiationService.createInstance(RemoteUserDataSyncActivityViewDataProvider)
-            : this.instantiationService.createInstance(LocalUserDataSyncActivityViewDataProvider);
-        this._register(Event.any(this.userDataSyncEnablementService.onDidChangeResourceEnablement, this.userDataSyncEnablementService.onDidChangeEnablement, this.userDataSyncService.onDidResetLocal, this.userDataSyncService.onDidResetRemote)(() => treeView.refresh()));
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        viewsRegistry.registerViews([{
-                id,
-                name,
-                ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
-                when: ( ContextKeyExpr.and(( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" )), ( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), CONTEXT_ENABLE_ACTIVITY_VIEWS)),
-                canToggleVisibility: true,
-                canMoveView: false,
-                treeView,
-                collapsed: false,
-                order: remote ? 200 : 400,
-                hideByDefault: !remote,
-            }], container);
-        this.registerDataViewActions(id);
-    }
-    registerExternalActivityView(container) {
-        const id = `workbench.views.sync.externalActivity`;
-        const name = ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'downloaded sync activity title',
-            "Sync Activity (Developer)"
-        ));
-        const dataProvider = this.instantiationService.createInstance(ExtractedUserDataSyncActivityViewDataProvider, undefined);
-        const treeView = this.instantiationService.createInstance(TreeView, id, name.value);
-        treeView.showCollapseAllAction = false;
-        treeView.showRefreshAction = false;
-        treeView.dataProvider = dataProvider;
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        viewsRegistry.registerViews([{
-                id,
-                name,
-                ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
-                when: CONTEXT_ENABLE_ACTIVITY_VIEWS,
-                canToggleVisibility: true,
-                canMoveView: false,
-                treeView,
-                collapsed: false,
-                hideByDefault: false,
-            }], container);
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.actions.sync.loadActivity`,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'workbench.actions.sync.loadActivity',
-                        "Load Sync Activity"
-                    )),
-                    icon: Codicon.cloudUpload,
-                    menu: {
-                        id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.equals('view', id)),
-                        group: 'navigation',
-                    },
-                });
-            }
-            async run(accessor) {
-                const fileDialogService = accessor.get(IFileDialogService);
-                const result = await fileDialogService.showOpenDialog({
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'select sync activity file',
-                        "Select Sync Activity File or Folder"
-                    )),
-                    canSelectFiles: true,
-                    canSelectFolders: true,
-                    canSelectMany: false,
-                });
-                if (!result?.[0]) {
-                    return;
-                }
-                dataProvider.activityDataResource = result[0];
-                await treeView.refresh();
-            }
-        }));
-    }
-    registerDataViewActions(viewId) {
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.actions.sync.${viewId}.resolveResource`,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'workbench.actions.sync.resolveResourceRef',
-                        "Show raw JSON sync data"
-                    )),
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /sync-resource-.*/i))))
-                    },
-                });
-            }
-            async run(accessor, handle) {
-                const { resource } = JSON.parse(handle.$treeItemHandle);
-                const editorService = accessor.get(IEditorService);
-                await editorService.openEditor({ resource: ( URI.parse(resource)), options: { pinned: true } });
-            }
-        }));
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.actions.sync.${viewId}.compareWithLocal`,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'workbench.actions.sync.compareWithLocal',
-                        "Compare with Local"
-                    )),
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /sync-associatedResource-.*/i))))
-                    },
-                });
-            }
-            async run(accessor, handle) {
-                const commandService = accessor.get(ICommandService);
-                const { resource, comparableResource } = JSON.parse(handle.$treeItemHandle);
-                const remoteResource = ( URI.parse(resource));
-                const localResource = ( URI.parse(comparableResource));
-                return commandService.executeCommand(API_OPEN_DIFF_EDITOR_COMMAND_ID, remoteResource, localResource, ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                    'remoteToLocalDiff',
-                    "{0} ↔ {1}",
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        { key: 'leftResourceName', comment: ['remote as in file in cloud'] },
-                        "{0} (Remote)",
-                        basename(remoteResource)
-                    )),
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        { key: 'rightResourceName', comment: ['local as in file in disk'] },
-                        "{0} (Local)",
-                        basename(localResource)
-                    ))
-                )), undefined);
-            }
-        }));
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: `workbench.actions.sync.${viewId}.replaceCurrent`,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'workbench.actions.sync.replaceCurrent',
-                        "Restore"
-                    )),
-                    icon: Codicon.discard,
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /sync-resource-.*/i)))),
-                        group: 'inline',
-                    },
-                });
-            }
-            async run(accessor, handle) {
-                const dialogService = accessor.get(IDialogService);
-                const userDataSyncService = accessor.get(IUserDataSyncService);
-                const { syncResourceHandle, syncResource } = JSON.parse(handle.$treeItemHandle);
-                const result = await dialogService.confirm({
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        { key: 'confirm replace', comment: ['A confirmation message to replace current user data (settings, extensions, keybindings, snippets) with selected version'] },
-                        "Would you like to replace your current {0} with selected?",
-                        getSyncAreaLabel(syncResource)
-                    )),
-                    type: 'info',
-                    title: SYNC_TITLE.value
-                });
-                if (result.confirmed) {
-                    return userDataSyncService.replace({ created: syncResourceHandle.created, uri: URI.revive(syncResourceHandle.uri) });
-                }
-            }
-        }));
-    }
-    registerTroubleShootView(container) {
-        const id = `workbench.views.sync.troubleshoot`;
-        const name = ( localize2WithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'troubleshoot',
-            "Troubleshoot"
-        ));
-        const treeView = this.instantiationService.createInstance(TreeView, id, name.value);
-        const dataProvider = this.instantiationService.createInstance(UserDataSyncTroubleshootViewDataProvider);
-        treeView.showRefreshAction = true;
-        treeView.dataProvider = dataProvider;
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        viewsRegistry.registerViews([{
-                id,
-                name,
-                ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
-                when: CONTEXT_ENABLE_ACTIVITY_VIEWS,
-                canToggleVisibility: true,
-                canMoveView: false,
-                treeView,
-                collapsed: false,
-                order: 500,
-                hideByDefault: true
-            }], container);
-    }
-};
-UserDataSyncDataViews = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IUserDataSyncEnablementService)),
-    ( __param(3, IUserDataSyncMachinesService)),
-    ( __param(4, IUserDataSyncService))
-], UserDataSyncDataViews));
-let UserDataSyncActivityViewDataProvider = class UserDataSyncActivityViewDataProvider {
-    constructor(userDataSyncService, userDataSyncResourceProviderService, userDataAutoSyncService, userDataSyncWorkbenchService, notificationService, userDataProfilesService) {
-        this.userDataSyncService = userDataSyncService;
-        this.userDataSyncResourceProviderService = userDataSyncResourceProviderService;
-        this.userDataAutoSyncService = userDataAutoSyncService;
-        this.userDataSyncWorkbenchService = userDataSyncWorkbenchService;
-        this.notificationService = notificationService;
-        this.userDataProfilesService = userDataProfilesService;
-        this.syncResourceHandlesByProfile = ( new Map());
-    }
-    async getChildren(element) {
-        try {
-            if (!element) {
-                return await this.getRoots();
-            }
-            if (element.profile || element.handle === this.userDataProfilesService.defaultProfile.id) {
-                let promise = this.syncResourceHandlesByProfile.get(element.handle);
-                if (!promise) {
-                    this.syncResourceHandlesByProfile.set(element.handle, promise = this.getSyncResourceHandles(element.profile));
-                }
-                return await promise;
-            }
-            if (element.syncResourceHandle) {
-                return await this.getChildrenForSyncResourceTreeItem(element);
-            }
-            return [];
-        }
-        catch (error) {
-            if (!(error instanceof UserDataSyncError)) {
-                error = UserDataSyncError.toUserDataSyncError(error);
-            }
-            if (error instanceof UserDataSyncError && error.code === "IncompatibleRemoteContent" ) {
-                this.notificationService.notify({
-                    severity: Severity.Error,
-                    message: error.message,
-                    actions: {
-                        primary: [
-                            ( new Action('reset', ( localizeWithPath(
-                                'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                                'reset',
-                                "Reset Synced Data"
-                            )), undefined, true, () => this.userDataSyncWorkbenchService.resetSyncedData())),
-                        ]
-                    }
-                });
-            }
-            else {
-                this.notificationService.error(error);
-            }
-            throw error;
-        }
-    }
-    async getRoots() {
-        this.syncResourceHandlesByProfile.clear();
-        const roots = [];
-        const profiles = await this.getProfiles();
-        if (profiles.length) {
-            const profileTreeItem = {
-                handle: this.userDataProfilesService.defaultProfile.id,
-                label: { label: this.userDataProfilesService.defaultProfile.name },
-                collapsibleState: TreeItemCollapsibleState.Expanded,
-            };
-            roots.push(profileTreeItem);
-        }
-        else {
-            const defaultSyncResourceHandles = await this.getSyncResourceHandles();
-            roots.push(...defaultSyncResourceHandles);
-        }
-        for (const profile of profiles) {
-            const profileTreeItem = {
-                handle: profile.id,
-                label: { label: profile.name },
-                collapsibleState: TreeItemCollapsibleState.Collapsed,
-                profile,
-            };
-            roots.push(profileTreeItem);
-        }
-        return roots;
-    }
-    async getChildrenForSyncResourceTreeItem(element) {
-        const syncResourceHandle = element.syncResourceHandle;
-        const associatedResources = await this.userDataSyncResourceProviderService.getAssociatedResources(syncResourceHandle);
-        const previousAssociatedResources = syncResourceHandle.previous ? await this.userDataSyncResourceProviderService.getAssociatedResources(syncResourceHandle.previous) : [];
-        return ( associatedResources.map(({ resource, comparableResource }) => {
-            const handle = JSON.stringify({ resource: ( resource.toString()), comparableResource: ( comparableResource.toString()) });
-            const previousResource = previousAssociatedResources.find(previous => basename(previous.resource) === basename(resource))?.resource;
-            return {
-                handle,
-                collapsibleState: TreeItemCollapsibleState.None,
-                resourceUri: resource,
-                command: previousResource ? {
-                    id: API_OPEN_DIFF_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [
-                        previousResource,
-                        resource,
-                        ( localizeWithPath(
-                            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                            'sideBySideLabels',
-                            "{0} ↔ {1}",
-                            `${basename(resource)} (${fromNow(syncResourceHandle.previous.created, true)})`,
-                            `${basename(resource)} (${fromNow(syncResourceHandle.created, true)})`
-                        )),
-                        undefined
-                    ]
-                } : {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: '',
-                    arguments: [resource, undefined, undefined]
-                },
-                contextValue: `sync-associatedResource-${syncResourceHandle.syncResource}`
-            };
-        }));
-    }
-    async getSyncResourceHandles(profile) {
-        const treeItems = [];
-        const result = await Promise.all(( ALL_SYNC_RESOURCES.map(async (syncResource) => {
-            const resourceHandles = await this.getResourceHandles(syncResource, profile);
-            return ( resourceHandles.map(
-                (resourceHandle, index) => ({ ...resourceHandle, syncResource, previous: resourceHandles[index + 1] })
-            ));
-        })));
-        const syncResourceHandles = result.flat().sort((a, b) => b.created - a.created);
-        for (const syncResourceHandle of syncResourceHandles) {
-            const handle = JSON.stringify({ syncResourceHandle, syncResource: syncResourceHandle.syncResource });
-            treeItems.push({
-                handle,
-                collapsibleState: TreeItemCollapsibleState.Collapsed,
-                label: { label: getSyncAreaLabel(syncResourceHandle.syncResource) },
-                description: fromNow(syncResourceHandle.created, true),
-                tooltip: ( new Date(syncResourceHandle.created)).toLocaleString(),
-                themeIcon: FolderThemeIcon,
-                syncResourceHandle,
-                contextValue: `sync-resource-${syncResourceHandle.syncResource}`
-            });
-        }
-        return treeItems;
-    }
-};
-UserDataSyncActivityViewDataProvider = ( __decorate([
-    ( __param(0, IUserDataSyncService)),
-    ( __param(1, IUserDataSyncResourceProviderService)),
-    ( __param(2, IUserDataAutoSyncService)),
-    ( __param(3, IUserDataSyncWorkbenchService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IUserDataProfilesService))
-], UserDataSyncActivityViewDataProvider));
-class LocalUserDataSyncActivityViewDataProvider extends UserDataSyncActivityViewDataProvider {
-    getResourceHandles(syncResource, profile) {
-        return this.userDataSyncResourceProviderService.getLocalSyncResourceHandles(syncResource, profile);
-    }
-    async getProfiles() {
-        return ( this.userDataProfilesService.profiles
-            .filter(p => !p.isDefault)
-            .map(p => ({
-            id: p.id,
-            collection: p.id,
-            name: p.name,
-        })));
-    }
-}
-let RemoteUserDataSyncActivityViewDataProvider = class RemoteUserDataSyncActivityViewDataProvider extends UserDataSyncActivityViewDataProvider {
-    constructor(userDataSyncService, userDataSyncResourceProviderService, userDataAutoSyncService, userDataSyncMachinesService, userDataSyncWorkbenchService, notificationService, userDataProfilesService) {
-        super(userDataSyncService, userDataSyncResourceProviderService, userDataAutoSyncService, userDataSyncWorkbenchService, notificationService, userDataProfilesService);
-        this.userDataSyncMachinesService = userDataSyncMachinesService;
-    }
-    async getChildren(element) {
-        if (!element) {
-            this.machinesPromise = undefined;
-        }
-        return super.getChildren(element);
-    }
-    getMachines() {
-        if (this.machinesPromise === undefined) {
-            this.machinesPromise = this.userDataSyncMachinesService.getMachines();
-        }
-        return this.machinesPromise;
-    }
-    getResourceHandles(syncResource, profile) {
-        return this.userDataSyncResourceProviderService.getRemoteSyncResourceHandles(syncResource, profile);
-    }
-    getProfiles() {
-        return this.userDataSyncResourceProviderService.getRemoteSyncedProfiles();
-    }
-    async getChildrenForSyncResourceTreeItem(element) {
-        const children = await super.getChildrenForSyncResourceTreeItem(element);
-        if (children.length) {
-            const machineId = await this.userDataSyncResourceProviderService.getMachineId(element.syncResourceHandle);
-            if (machineId) {
-                const machines = await this.getMachines();
-                const machine = machines.find(({ id }) => id === machineId);
-                children[0].description = machine?.isCurrent ? ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                    { key: 'current', comment: ['Represents current machine'] },
-                    "Current"
-                )) : machine?.name;
-            }
-        }
-        return children;
-    }
-};
-RemoteUserDataSyncActivityViewDataProvider = ( __decorate([
-    ( __param(0, IUserDataSyncService)),
-    ( __param(1, IUserDataSyncResourceProviderService)),
-    ( __param(2, IUserDataAutoSyncService)),
-    ( __param(3, IUserDataSyncMachinesService)),
-    ( __param(4, IUserDataSyncWorkbenchService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IUserDataProfilesService))
-], RemoteUserDataSyncActivityViewDataProvider));
-let ExtractedUserDataSyncActivityViewDataProvider = class ExtractedUserDataSyncActivityViewDataProvider extends UserDataSyncActivityViewDataProvider {
-    constructor(activityDataResource, userDataSyncService, userDataSyncResourceProviderService, userDataAutoSyncService, userDataSyncWorkbenchService, notificationService, userDataProfilesService, fileService, uriIdentityService) {
-        super(userDataSyncService, userDataSyncResourceProviderService, userDataAutoSyncService, userDataSyncWorkbenchService, notificationService, userDataProfilesService);
-        this.activityDataResource = activityDataResource;
-        this.fileService = fileService;
-        this.uriIdentityService = uriIdentityService;
-    }
-    async getChildren(element) {
-        if (!element) {
-            this.machinesPromise = undefined;
-            if (!this.activityDataResource) {
-                return [];
-            }
-            const stat = await this.fileService.resolve(this.activityDataResource);
-            if (stat.isDirectory) {
-                this.activityDataLocation = this.activityDataResource;
-            }
-            else {
-                this.activityDataLocation = this.uriIdentityService.extUri.joinPath(this.uriIdentityService.extUri.dirname(this.activityDataResource), 'remoteActivity');
-                try {
-                    await this.fileService.del(this.activityDataLocation, { recursive: true });
-                }
-                catch (e) {  }
-                await this.userDataSyncService.extractActivityData(this.activityDataResource, this.activityDataLocation);
-            }
-        }
-        return super.getChildren(element);
-    }
-    getResourceHandles(syncResource, profile) {
-        return this.userDataSyncResourceProviderService.getLocalSyncResourceHandles(syncResource, profile, this.activityDataLocation);
-    }
-    async getProfiles() {
-        return this.userDataSyncResourceProviderService.getLocalSyncedProfiles(this.activityDataLocation);
-    }
-    async getChildrenForSyncResourceTreeItem(element) {
-        const children = await super.getChildrenForSyncResourceTreeItem(element);
-        if (children.length) {
-            const machineId = await this.userDataSyncResourceProviderService.getMachineId(element.syncResourceHandle);
-            if (machineId) {
-                const machines = await this.getMachines();
-                const machine = machines.find(({ id }) => id === machineId);
-                children[0].description = machine?.isCurrent ? ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                    { key: 'current', comment: ['Represents current machine'] },
-                    "Current"
-                )) : machine?.name;
-            }
-        }
-        return children;
-    }
-    getMachines() {
-        if (this.machinesPromise === undefined) {
-            this.machinesPromise = this.userDataSyncResourceProviderService.getLocalSyncedMachines(this.activityDataLocation);
-        }
-        return this.machinesPromise;
-    }
-};
-ExtractedUserDataSyncActivityViewDataProvider = ( __decorate([
-    ( __param(1, IUserDataSyncService)),
-    ( __param(2, IUserDataSyncResourceProviderService)),
-    ( __param(3, IUserDataAutoSyncService)),
-    ( __param(4, IUserDataSyncWorkbenchService)),
-    ( __param(5, INotificationService)),
-    ( __param(6, IUserDataProfilesService)),
-    ( __param(7, IFileService)),
-    ( __param(8, IUriIdentityService))
-], ExtractedUserDataSyncActivityViewDataProvider));
-let UserDataSyncMachinesViewDataProvider = class UserDataSyncMachinesViewDataProvider {
-    constructor(treeView, userDataSyncMachinesService, quickInputService, notificationService, dialogService, userDataSyncWorkbenchService) {
-        this.treeView = treeView;
-        this.userDataSyncMachinesService = userDataSyncMachinesService;
-        this.quickInputService = quickInputService;
-        this.notificationService = notificationService;
-        this.dialogService = dialogService;
-        this.userDataSyncWorkbenchService = userDataSyncWorkbenchService;
-    }
-    async getChildren(element) {
-        if (!element) {
-            this.machinesPromise = undefined;
-        }
-        try {
-            let machines = await this.getMachines();
-            machines = machines.filter(m => !m.disabled).sort((m1, m2) => m1.isCurrent ? -1 : 1);
-            this.treeView.message = machines.length ? undefined : ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                'no machines',
-                "No Machines"
-            ));
-            return ( machines.map(({ id, name, isCurrent, platform }) => ({
-                handle: id,
-                collapsibleState: TreeItemCollapsibleState.None,
-                label: { label: name },
-                description: isCurrent ? ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                    { key: 'current', comment: ['Current machine'] },
-                    "Current"
-                )) : undefined,
-                themeIcon: platform && isWebPlatform(platform) ? Codicon.globe : Codicon.vm,
-                contextValue: 'sync-machine'
-            })));
-        }
-        catch (error) {
-            this.notificationService.error(error);
-            return [];
-        }
-    }
-    getMachines() {
-        if (this.machinesPromise === undefined) {
-            this.machinesPromise = this.userDataSyncMachinesService.getMachines();
-        }
-        return this.machinesPromise;
-    }
-    async disable(machineIds) {
-        const machines = await this.getMachines();
-        const machinesToDisable = machines.filter(({ id }) => machineIds.includes(id));
-        if (!machinesToDisable.length) {
-            throw new Error(localizeWithPath('vs/workbench/contrib/userDataSync/browser/userDataSyncViews', 'not found', "machine not found with id: {0}", machineIds.join(',')));
-        }
-        const result = await this.dialogService.confirm({
-            type: 'info',
-            message: machinesToDisable.length > 1 ? ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                'turn off sync on multiple machines',
-                "Are you sure you want to turn off sync on selected machines?"
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                'turn off sync on machine',
-                "Are you sure you want to turn off sync on {0}?",
-                machinesToDisable[0].name
-            )),
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                { key: 'turn off', comment: ['&& denotes a mnemonic'] },
-                "&&Turn off"
-            )),
-        });
-        if (!result.confirmed) {
-            return false;
-        }
-        if (( machinesToDisable.some(machine => machine.isCurrent))) {
-            await this.userDataSyncWorkbenchService.turnoff(false);
-        }
-        const otherMachinesToDisable = ( machinesToDisable.filter(machine => !machine.isCurrent)
-            .map(machine => ([machine.id, false])));
-        if (otherMachinesToDisable.length) {
-            await this.userDataSyncMachinesService.setEnablements(otherMachinesToDisable);
-        }
-        return true;
-    }
-    async rename(machineId) {
-        const disposableStore = ( new DisposableStore());
-        const inputBox = disposableStore.add(this.quickInputService.createInputBox());
-        inputBox.placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'placeholder',
-            "Enter the name of the machine"
-        ));
-        inputBox.busy = true;
-        inputBox.show();
-        const machines = await this.getMachines();
-        const machine = machines.find(({ id }) => id === machineId);
-        if (!machine) {
-            inputBox.hide();
-            disposableStore.dispose();
-            throw new Error(localizeWithPath('vs/workbench/contrib/userDataSync/browser/userDataSyncViews', 'not found', "machine not found with id: {0}", machineId));
-        }
-        inputBox.busy = false;
-        inputBox.value = machine.name;
-        const validateMachineName = (machineName) => {
-            machineName = machineName.trim();
-            return machineName && !( machines.some(m => m.id !== machineId && m.name === machineName)) ? machineName : null;
-        };
-        disposableStore.add(inputBox.onDidChangeValue(() => inputBox.validationMessage = validateMachineName(inputBox.value) ? '' : ( localizeWithPath(
-            'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-            'valid message',
-            "Machine name should be unique and not empty"
-        ))));
-        return ( new Promise((c, e) => {
-            disposableStore.add(inputBox.onDidAccept(async () => {
-                const machineName = validateMachineName(inputBox.value);
-                disposableStore.dispose();
-                if (machineName && machineName !== machine.name) {
-                    try {
-                        await this.userDataSyncMachinesService.renameMachine(machineId, machineName);
-                        c(true);
-                    }
-                    catch (error) {
-                        e(error);
-                    }
-                }
-                else {
-                    c(false);
-                }
-            }));
-        }));
-    }
-};
-UserDataSyncMachinesViewDataProvider = ( __decorate([
-    ( __param(1, IUserDataSyncMachinesService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IDialogService)),
-    ( __param(5, IUserDataSyncWorkbenchService))
-], UserDataSyncMachinesViewDataProvider));
-let UserDataSyncTroubleshootViewDataProvider = class UserDataSyncTroubleshootViewDataProvider {
-    constructor(fileService, userDataSyncWorkbenchService, environmentService, uriIdentityService) {
-        this.fileService = fileService;
-        this.userDataSyncWorkbenchService = userDataSyncWorkbenchService;
-        this.environmentService = environmentService;
-        this.uriIdentityService = uriIdentityService;
-    }
-    async getChildren(element) {
-        if (!element) {
-            return [{
-                    handle: 'SYNC_LOGS',
-                    collapsibleState: TreeItemCollapsibleState.Collapsed,
-                    label: { label: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'sync logs',
-                        "Logs"
-                    )) },
-                    themeIcon: Codicon.folder,
-                }, {
-                    handle: 'LAST_SYNC_STATES',
-                    collapsibleState: TreeItemCollapsibleState.Collapsed,
-                    label: { label: ( localizeWithPath(
-                        'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                        'last sync states',
-                        "Last Synced Remotes"
-                    )) },
-                    themeIcon: Codicon.folder,
-                }];
-        }
-        if (element.handle === 'LAST_SYNC_STATES') {
-            return this.getLastSyncStates();
-        }
-        if (element.handle === 'SYNC_LOGS') {
-            return this.getSyncLogs();
-        }
-        return [];
-    }
-    async getLastSyncStates() {
-        const result = [];
-        for (const syncResource of ALL_SYNC_RESOURCES) {
-            const resource = getLastSyncResourceUri(undefined, syncResource, this.environmentService, this.uriIdentityService.extUri);
-            if (await this.fileService.exists(resource)) {
-                result.push({
-                    handle: ( resource.toString()),
-                    label: { label: getSyncAreaLabel(syncResource) },
-                    collapsibleState: TreeItemCollapsibleState.None,
-                    resourceUri: resource,
-                    command: { id: API_OPEN_EDITOR_COMMAND_ID, title: '', arguments: [resource, undefined, undefined] },
-                });
-            }
-        }
-        return result;
-    }
-    async getSyncLogs() {
-        const logResources = await this.userDataSyncWorkbenchService.getAllLogResources();
-        const result = [];
-        for (const syncLogResource of logResources) {
-            const logFolder = this.uriIdentityService.extUri.dirname(syncLogResource);
-            result.push({
-                handle: ( syncLogResource.toString()),
-                collapsibleState: TreeItemCollapsibleState.None,
-                resourceUri: syncLogResource,
-                label: { label: this.uriIdentityService.extUri.basename(logFolder) },
-                description: this.uriIdentityService.extUri.isEqual(logFolder, this.environmentService.logsHome) ? ( localizeWithPath(
-                    'vs/workbench/contrib/userDataSync/browser/userDataSyncViews',
-                    { key: 'current', comment: ['Represents current log file'] },
-                    "Current"
-                )) : undefined,
-                command: { id: API_OPEN_EDITOR_COMMAND_ID, title: '', arguments: [syncLogResource, undefined, undefined] },
-            });
-        }
-        return result;
-    }
-};
-UserDataSyncTroubleshootViewDataProvider = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IUserDataSyncWorkbenchService)),
-    ( __param(2, IEnvironmentService)),
-    ( __param(3, IUriIdentityService))
-], UserDataSyncTroubleshootViewDataProvider));
-export { UserDataSyncDataViews };