@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,217 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,310 +0,0 @@
-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 };