@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/api/browser/mainThreadTesting.js

@@ -0,0 +1,217 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from '../../../base/common/event.js';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { transaction } from '../../../base/common/observableInternal/base.js';
+import '../../../base/common/observableInternal/derived.js';
+import '../../../base/common/observableInternal/autorun.js';
+import '../../../base/common/observableInternal/utils.js';
+import '../../../base/common/cancellation.js';
+import { WellDefinedPrefixTree } from '../../../base/common/prefixTree.js';
+import { URI } from '../../../base/common/uri.js';
+import { Range } from '../../../editor/common/core/range.js';
+import { IUriIdentityService } from '../../../platform/uriIdentity/common/uriIdentity.js';
+import { MutableObservableValue } from '../../contrib/testing/common/observableValue.js';
+import { TestCoverage } from '../../contrib/testing/common/testCoverage.js';
+import { TestId } from '../../contrib/testing/common/testId.js';
+import { ITestProfileService } from '../../contrib/testing/common/testProfileService.js';
+import { LiveTestResult } from '../../contrib/testing/common/testResult.js';
+import { ITestResultService } from '../../contrib/testing/common/testResultService.js';
+import { ITestService } from '../../contrib/testing/common/testService.js';
+import { ITestItem, IFileCoverage, CoverageDetails, ITestMessage, TestsDiffOp } from '../../contrib/testing/common/testTypes.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+let MainThreadTesting = class MainThreadTesting extends Disposable {
+    constructor(extHostContext, uriIdentityService, testService, testProfiles, resultService) {
+        super();
+        this.uriIdentityService = uriIdentityService;
+        this.testService = testService;
+        this.testProfiles = testProfiles;
+        this.resultService = resultService;
+        this.diffListener = this._register(( new MutableDisposable()));
+        this.testProviderRegistrations = ( new Map());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTesting));
+        this._register(this.testService.onDidCancelTestRun(({ runId }) => {
+            this.proxy.$cancelExtensionTestRun(runId);
+        }));
+        this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => {
+            const obj = {};
+            for (const group of [2 , 4 , 8 ]) {
+                for (const profile of this.testProfiles.getGroupDefaultProfiles(group)) {
+                    obj[profile.controllerId] ??= [];
+                    obj[profile.controllerId].push(profile.profileId);
+                }
+            }
+            this.proxy.$setDefaultRunProfiles(obj);
+        }));
+        this._register(resultService.onResultsChanged(evt => {
+            if ('completed' in evt) {
+                const serialized = evt.completed.toJSONWithMessages();
+                if (serialized) {
+                    this.proxy.$publishTestResults([serialized]);
+                }
+            }
+            else if ('removed' in evt) {
+                evt.removed.forEach(r => {
+                    if (r instanceof LiveTestResult) {
+                        this.proxy.$disposeRun(r.id);
+                    }
+                });
+            }
+        }));
+    }
+    $markTestRetired(testIds) {
+        let tree;
+        if (testIds) {
+            tree = ( new WellDefinedPrefixTree());
+            for (const id of testIds) {
+                tree.insert(TestId.fromString(id).path, undefined);
+            }
+        }
+        for (const result of this.resultService.results) {
+            if (result instanceof LiveTestResult) {
+                result.markRetired(tree);
+            }
+        }
+    }
+    $publishTestRunProfile(profile) {
+        const controller = this.testProviderRegistrations.get(profile.controllerId);
+        if (controller) {
+            this.testProfiles.addProfile(controller.instance, profile);
+        }
+    }
+    $updateTestRunConfig(controllerId, profileId, update) {
+        this.testProfiles.updateProfile(controllerId, profileId, update);
+    }
+    $removeTestProfile(controllerId, profileId) {
+        this.testProfiles.removeProfile(controllerId, profileId);
+    }
+    $addTestsToRun(controllerId, runId, tests) {
+        this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(t => ITestItem.deserialize(this.uriIdentityService, t)))));
+    }
+    $appendCoverage(runId, taskId, coverage) {
+        this.withLiveRun(runId, run => {
+            const task = run.tasks.find(t => t.id === taskId);
+            if (!task) {
+                return;
+            }
+            const deserialized = IFileCoverage.deserialize(this.uriIdentityService, coverage);
+            transaction(tx => {
+                let value = task.coverage.read(undefined);
+                if (!value) {
+                    value = ( new TestCoverage(taskId, this.uriIdentityService, {
+                        getCoverageDetails: (id, token) => this.proxy.$getCoverageDetails(id, token)
+                            .then(r => ( r.map(CoverageDetails.deserialize))),
+                    }));
+                    value.append(deserialized, tx);
+                    task.coverage.set(value, tx);
+                }
+                else {
+                    value.append(deserialized, tx);
+                }
+            });
+        });
+    }
+    $startedExtensionTestRun(req) {
+        this.resultService.createLiveResult(req);
+    }
+    $startedTestRunTask(runId, task) {
+        this.withLiveRun(runId, r => r.addTask(task));
+    }
+    $finishedTestRunTask(runId, taskId) {
+        this.withLiveRun(runId, r => r.markTaskComplete(taskId));
+    }
+    $finishedExtensionTestRun(runId) {
+        this.withLiveRun(runId, r => r.markComplete());
+    }
+    $updateTestStateInRun(runId, taskId, testId, state, duration) {
+        this.withLiveRun(runId, r => r.updateState(testId, taskId, state, duration));
+    }
+    $appendOutputToRun(runId, taskId, output, locationDto, testId) {
+        const location = locationDto && {
+            uri: URI.revive(locationDto.uri),
+            range: Range.lift(locationDto.range)
+        };
+        this.withLiveRun(runId, r => r.appendOutput(output, taskId, location, testId));
+    }
+    $appendTestMessagesInRun(runId, taskId, testId, messages) {
+        const r = this.resultService.getResult(runId);
+        if (r && r instanceof LiveTestResult) {
+            for (const message of messages) {
+                r.appendMessage(testId, taskId, ITestMessage.deserialize(this.uriIdentityService, message));
+            }
+        }
+    }
+    $registerTestController(controllerId, labelStr, canRefreshValue) {
+        const disposable = ( new DisposableStore());
+        const label = disposable.add(( new MutableObservableValue(labelStr)));
+        const canRefresh = disposable.add(( new MutableObservableValue(canRefreshValue)));
+        const controller = {
+            id: controllerId,
+            label,
+            canRefresh,
+            syncTests: () => this.proxy.$syncTests(),
+            refreshTests: token => this.proxy.$refreshTests(controllerId, token),
+            configureRunProfile: id => this.proxy.$configureRunProfile(controllerId, id),
+            runTests: (reqs, token) => this.proxy.$runControllerTests(reqs, token),
+            startContinuousRun: (reqs, token) => this.proxy.$startContinuousRun(reqs, token),
+            expandTest: (testId, levels) => this.proxy.$expandTest(testId, isFinite(levels) ? levels : -1),
+        };
+        disposable.add(toDisposable(() => this.testProfiles.removeProfile(controllerId)));
+        disposable.add(this.testService.registerTestController(controllerId, controller));
+        this.testProviderRegistrations.set(controllerId, {
+            instance: controller,
+            label,
+            canRefresh,
+            disposable
+        });
+    }
+    $updateController(controllerId, patch) {
+        const controller = this.testProviderRegistrations.get(controllerId);
+        if (!controller) {
+            return;
+        }
+        if (patch.label !== undefined) {
+            controller.label.value = patch.label;
+        }
+        if (patch.canRefresh !== undefined) {
+            controller.canRefresh.value = patch.canRefresh;
+        }
+    }
+    $unregisterTestController(controllerId) {
+        this.testProviderRegistrations.get(controllerId)?.disposable.dispose();
+        this.testProviderRegistrations.delete(controllerId);
+    }
+    $subscribeToDiffs() {
+        this.proxy.$acceptDiff(( this.testService.collection.getReviverDiff().map(TestsDiffOp.serialize)));
+        this.diffListener.value = this.testService.onDidProcessDiff(this.proxy.$acceptDiff, this.proxy);
+    }
+    $unsubscribeFromDiffs() {
+        this.diffListener.clear();
+    }
+    $publishDiff(controllerId, diff) {
+        this.testService.publishDiff(controllerId, ( diff.map(d => TestsDiffOp.deserialize(this.uriIdentityService, d))));
+    }
+    async $runTests(req, token) {
+        const result = await this.testService.runResolvedTests(req, token);
+        return result.id;
+    }
+    dispose() {
+        super.dispose();
+        for (const subscription of ( this.testProviderRegistrations.values())) {
+            subscription.disposable.dispose();
+        }
+        this.testProviderRegistrations.clear();
+    }
+    withLiveRun(runId, fn) {
+        const r = this.resultService.getResult(runId);
+        return r && r instanceof LiveTestResult ? fn(r) : undefined;
+    }
+};
+MainThreadTesting = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTesting),
+    ( __param(1, IUriIdentityService)),
+    ( __param(2, ITestService)),
+    ( __param(3, ITestProfileService)),
+    ( __param(4, ITestResultService))
+], MainThreadTesting);
+export { MainThreadTesting };

package/vscode/src/vs/workbench/api/browser/mainThreadTheming.js

@@ -0,0 +1,22 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IThemeService } from '../../../platform/theme/common/themeService.js';
+let MainThreadTheming = class MainThreadTheming {
+    constructor(extHostContext, themeService) {
+        this._themeService = themeService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTheming));
+        this._themeChangeListener = this._themeService.onDidColorThemeChange(e => {
+            this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
+        });
+        this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
+    }
+    dispose() {
+        this._themeChangeListener.dispose();
+    }
+};
+MainThreadTheming = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTheming),
+    ( __param(1, IThemeService))
+], MainThreadTheming);
+export { MainThreadTheming };

package/vscode/src/vs/workbench/api/browser/mainThreadTimeline.js

@@ -0,0 +1,53 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ITimelineService } from '../../contrib/timeline/common/timeline.js';
+import { revive } from '../../../base/common/marshalling.js';
+let MainThreadTimeline = class MainThreadTimeline {
+    constructor(context, logService, _timelineService) {
+        this.logService = logService;
+        this._timelineService = _timelineService;
+        this._providerEmitters = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostTimeline));
+    }
+    $registerTimelineProvider(provider) {
+        this.logService.trace(`MainThreadTimeline#registerTimelineProvider: id=${provider.id}`);
+        const proxy = this._proxy;
+        const emitters = this._providerEmitters;
+        let onDidChange = emitters.get(provider.id);
+        if (onDidChange === undefined) {
+            onDidChange = ( new Emitter());
+            emitters.set(provider.id, onDidChange);
+        }
+        this._timelineService.registerTimelineProvider({
+            ...provider,
+            onDidChange: onDidChange.event,
+            async provideTimeline(uri, options, token) {
+                return revive(await proxy.$getTimeline(provider.id, uri, options, token));
+            },
+            dispose() {
+                emitters.delete(provider.id);
+                onDidChange?.dispose();
+            }
+        });
+    }
+    $unregisterTimelineProvider(id) {
+        this.logService.trace(`MainThreadTimeline#unregisterTimelineProvider: id=${id}`);
+        this._timelineService.unregisterTimelineProvider(id);
+    }
+    $emitTimelineChangeEvent(e) {
+        this.logService.trace(`MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`);
+        const emitter = this._providerEmitters.get(e.id);
+        emitter?.fire(e);
+    }
+    dispose() {
+    }
+};
+MainThreadTimeline = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTimeline),
+    ( __param(1, ILogService)),
+    ( __param(2, ITimelineService))
+], MainThreadTimeline);
+export { MainThreadTimeline };

package/vscode/src/vs/workbench/api/browser/mainThreadTreeViews.js

@@ -0,0 +1,310 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { Extensions, NoTreeViewError, ResolvableTreeItem } from '../../common/views.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { distinct } from '../../../base/common/arrays.js';
+import { INotificationService } from '../../../platform/notification/common/notification.js';
+import { isUndefinedOrNull, isNumber } from '../../../base/common/types.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { createStringDataTransferItem, VSDataTransfer } from '../../../base/common/dataTransfer.js';
+import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
+import { DataTransfer } from '../common/extHostTypeConverters.js';
+import { IViewsService } from '../../services/views/common/viewsService.js';
+let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
+    constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
+        super();
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.extensionService = extensionService;
+        this.logService = logService;
+        this._dataProviders = this._register(( new DisposableMap()));
+        this._dndControllers = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTreeViews));
+    }
+    async $registerTreeViewDataProvider(treeViewId, options) {
+        this.logService.trace('MainThreadTreeViews#$registerTreeViewDataProvider', treeViewId, options);
+        this.extensionService.whenInstalledExtensionsRegistered().then(() => {
+            const dataProvider = ( new TreeViewDataProvider(treeViewId, this._proxy, this.notificationService));
+            const disposables = ( new DisposableStore());
+            this._dataProviders.set(treeViewId, { dataProvider, dispose: () => disposables.dispose() });
+            const dndController = (options.hasHandleDrag || options.hasHandleDrop)
+                ? ( new TreeViewDragAndDropController(
+                treeViewId,
+                options.dropMimeTypes,
+                options.dragMimeTypes,
+                options.hasHandleDrag,
+                this._proxy
+            )) : undefined;
+            const viewer = this.getTreeView(treeViewId);
+            if (viewer) {
+                viewer.showCollapseAllAction = options.showCollapseAll;
+                viewer.canSelectMany = options.canSelectMany;
+                viewer.manuallyManageCheckboxes = options.manuallyManageCheckboxes;
+                viewer.dragAndDropController = dndController;
+                if (dndController) {
+                    this._dndControllers.set(treeViewId, dndController);
+                }
+                viewer.dataProvider = dataProvider;
+                this.registerListeners(treeViewId, viewer, disposables);
+                this._proxy.$setVisible(treeViewId, viewer.visible);
+            }
+            else {
+                this.notificationService.error('No view is registered with id: ' + treeViewId);
+            }
+        });
+    }
+    $reveal(treeViewId, itemInfo, options) {
+        this.logService.trace('MainThreadTreeViews#$reveal', treeViewId, itemInfo?.item, itemInfo?.parentChain, options);
+        return this.viewsService.openView(treeViewId, options.focus)
+            .then(() => {
+            const viewer = this.getTreeView(treeViewId);
+            if (viewer && itemInfo) {
+                return this.reveal(viewer, this._dataProviders.get(treeViewId).dataProvider, itemInfo.item, itemInfo.parentChain, options);
+            }
+            return undefined;
+        });
+    }
+    $refresh(treeViewId, itemsToRefreshByHandle) {
+        this.logService.trace('MainThreadTreeViews#$refresh', treeViewId, itemsToRefreshByHandle);
+        const viewer = this.getTreeView(treeViewId);
+        const dataProvider = this._dataProviders.get(treeViewId);
+        if (viewer && dataProvider) {
+            const itemsToRefresh = dataProvider.dataProvider.getItemsToRefresh(itemsToRefreshByHandle);
+            return viewer.refresh(itemsToRefresh.length ? itemsToRefresh : undefined);
+        }
+        return Promise.resolve();
+    }
+    $setMessage(treeViewId, message) {
+        this.logService.trace('MainThreadTreeViews#$setMessage', treeViewId, ( message.toString()));
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.message = message;
+        }
+    }
+    $setTitle(treeViewId, title, description) {
+        this.logService.trace('MainThreadTreeViews#$setTitle', treeViewId, title, description);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.title = title;
+            viewer.description = description;
+        }
+    }
+    $setBadge(treeViewId, badge) {
+        this.logService.trace('MainThreadTreeViews#$setBadge', treeViewId, badge?.value, badge?.tooltip);
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.badge = badge;
+        }
+    }
+    $resolveDropFileData(destinationViewId, requestId, dataItemId) {
+        const controller = this._dndControllers.get(destinationViewId);
+        if (!controller) {
+            throw new Error('Unknown tree');
+        }
+        return controller.resolveDropFileData(requestId, dataItemId);
+    }
+    async $disposeTree(treeViewId) {
+        const viewer = this.getTreeView(treeViewId);
+        if (viewer) {
+            viewer.dataProvider = undefined;
+        }
+        this._dataProviders.deleteAndDispose(treeViewId);
+    }
+    async reveal(treeView, dataProvider, itemIn, parentChain, options) {
+        options = options ? options : { select: false, focus: false };
+        const select = isUndefinedOrNull(options.select) ? false : options.select;
+        const focus = isUndefinedOrNull(options.focus) ? false : options.focus;
+        let expand = Math.min(isNumber(options.expand) ? options.expand : options.expand === true ? 1 : 0, 3);
+        if (dataProvider.isEmpty()) {
+            await treeView.refresh();
+        }
+        for (const parent of parentChain) {
+            const parentItem = dataProvider.getItem(parent.handle);
+            if (parentItem) {
+                await treeView.expand(parentItem);
+            }
+        }
+        const item = dataProvider.getItem(itemIn.handle);
+        if (item) {
+            await treeView.reveal(item);
+            if (select) {
+                treeView.setSelection([item]);
+            }
+            if (focus === false) {
+                treeView.setFocus();
+            }
+            else if (focus) {
+                treeView.setFocus(item);
+            }
+            let itemsToExpand = [item];
+            for (; itemsToExpand.length > 0 && expand > 0; expand--) {
+                await treeView.expand(itemsToExpand);
+                itemsToExpand = itemsToExpand.reduce((result, itemValue) => {
+                    const item = dataProvider.getItem(itemValue.handle);
+                    if (item && item.children && item.children.length) {
+                        result.push(...item.children);
+                    }
+                    return result;
+                }, []);
+            }
+        }
+    }
+    registerListeners(treeViewId, treeView, disposables) {
+        disposables.add(treeView.onDidExpandItem(item => this._proxy.$setExpanded(treeViewId, item.handle, true)));
+        disposables.add(treeView.onDidCollapseItem(item => this._proxy.$setExpanded(treeViewId, item.handle, false)));
+        disposables.add(treeView.onDidChangeSelectionAndFocus(items => this._proxy.$setSelectionAndFocus(treeViewId, ( items.selection.map(({ handle }) => handle)), items.focus.handle)));
+        disposables.add(treeView.onDidChangeVisibility(isVisible => this._proxy.$setVisible(treeViewId, isVisible)));
+        disposables.add(treeView.onDidChangeCheckboxState(items => {
+            this._proxy.$changeCheckboxState(treeViewId, ( items.map(item => {
+                return { treeItemHandle: item.handle, newState: item.checkbox?.isChecked ?? false };
+            })));
+        }));
+    }
+    getTreeView(treeViewId) {
+        const viewDescriptor = ( Registry.as(Extensions.ViewsRegistry)).getView(treeViewId);
+        return viewDescriptor ? viewDescriptor.treeView : null;
+    }
+    dispose() {
+        for (const dataprovider of this._dataProviders) {
+            const treeView = this.getTreeView(dataprovider[0]);
+            if (treeView) {
+                treeView.dataProvider = undefined;
+            }
+        }
+        this._dataProviders.dispose();
+        this._dndControllers.clear();
+        super.dispose();
+    }
+};
+MainThreadTreeViews = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTreeViews),
+    ( __param(1, IViewsService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, ILogService))
+], MainThreadTreeViews);
+class TreeViewDragAndDropController {
+    constructor(treeViewId, dropMimeTypes, dragMimeTypes, hasWillDrop, _proxy) {
+        this.treeViewId = treeViewId;
+        this.dropMimeTypes = dropMimeTypes;
+        this.dragMimeTypes = dragMimeTypes;
+        this.hasWillDrop = hasWillDrop;
+        this._proxy = _proxy;
+        this.dataTransfersCache = ( new DataTransferFileCache());
+    }
+    async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
+        const request = this.dataTransfersCache.add(dataTransfer);
+        try {
+            const dataTransferDto = await DataTransfer.from(dataTransfer);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            return await this._proxy.$handleDrop(this.treeViewId, request.id, dataTransferDto, targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
+        }
+        finally {
+            request.dispose();
+        }
+    }
+    async handleDrag(sourceTreeItemHandles, operationUuid, token) {
+        if (!this.hasWillDrop) {
+            return;
+        }
+        const additionalDataTransferDTO = await this._proxy.$handleDrag(this.treeViewId, sourceTreeItemHandles, operationUuid, token);
+        if (!additionalDataTransferDTO) {
+            return;
+        }
+        const additionalDataTransfer = ( new VSDataTransfer());
+        additionalDataTransferDTO.items.forEach(([type, item]) => {
+            additionalDataTransfer.replace(type, createStringDataTransferItem(item.asString));
+        });
+        return additionalDataTransfer;
+    }
+    resolveDropFileData(requestId, dataItemId) {
+        return this.dataTransfersCache.resolveFileData(requestId, dataItemId);
+    }
+}
+class TreeViewDataProvider {
+    constructor(treeViewId, _proxy, notificationService) {
+        this.treeViewId = treeViewId;
+        this._proxy = _proxy;
+        this.notificationService = notificationService;
+        this.itemsMap = ( new Map());
+        this.hasResolve = this._proxy.$hasResolve(this.treeViewId);
+    }
+    getChildren(treeItem) {
+        if (!treeItem) {
+            this.itemsMap.clear();
+        }
+        return this._proxy.$getChildren(this.treeViewId, treeItem ? treeItem.handle : undefined)
+            .then(children => this.postGetChildren(children), err => {
+            if (!NoTreeViewError.is(err)) {
+                this.notificationService.error(err);
+            }
+            return [];
+        });
+    }
+    getItemsToRefresh(itemsToRefreshByHandle) {
+        const itemsToRefresh = [];
+        if (itemsToRefreshByHandle) {
+            for (const treeItemHandle of ( Object.keys(itemsToRefreshByHandle))) {
+                const currentTreeItem = this.getItem(treeItemHandle);
+                if (currentTreeItem) {
+                    const treeItem = itemsToRefreshByHandle[treeItemHandle];
+                    this.updateTreeItem(currentTreeItem, treeItem);
+                    if (treeItemHandle === treeItem.handle) {
+                        itemsToRefresh.push(currentTreeItem);
+                    }
+                    else {
+                        this.itemsMap.delete(treeItemHandle);
+                        this.itemsMap.set(currentTreeItem.handle, currentTreeItem);
+                        const parent = treeItem.parentHandle ? this.itemsMap.get(treeItem.parentHandle) : null;
+                        if (parent) {
+                            itemsToRefresh.push(parent);
+                        }
+                    }
+                }
+            }
+        }
+        return itemsToRefresh;
+    }
+    getItem(treeItemHandle) {
+        return this.itemsMap.get(treeItemHandle);
+    }
+    isEmpty() {
+        return this.itemsMap.size === 0;
+    }
+    async postGetChildren(elements) {
+        if (elements === undefined) {
+            return undefined;
+        }
+        const result = [];
+        const hasResolve = await this.hasResolve;
+        if (elements) {
+            for (const element of elements) {
+                const resolvable = ( new ResolvableTreeItem(element, hasResolve ? (token) => {
+                    return this._proxy.$resolve(this.treeViewId, element.handle, token);
+                } : undefined));
+                this.itemsMap.set(element.handle, resolvable);
+                result.push(resolvable);
+            }
+        }
+        return result;
+    }
+    updateTreeItem(current, treeItem) {
+        treeItem.children = treeItem.children ? treeItem.children : undefined;
+        if (current) {
+            const properties = distinct([...( Object.keys(current instanceof ResolvableTreeItem ? current.asTreeItem() : current)),
+                ...( Object.keys(treeItem))]);
+            for (const property of properties) {
+                current[property] = treeItem[property];
+            }
+            if (current instanceof ResolvableTreeItem) {
+                current.resetResolve();
+            }
+        }
+    }
+}
+export { MainThreadTreeViews };