@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -20,7 +20,13 @@ import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 let MainThreadTesting = class MainThreadTesting extends Disposable {
-    constructor(extHostContext, uriIdentityService, testService, testProfiles, resultService) {
+    constructor(
+        extHostContext,
+        uriIdentityService,
+        testService,
+        testProfiles,
+        resultService
+    ) {
         super();
         this.uriIdentityService = uriIdentityService;
         this.testService = testService;
@@ -33,14 +39,23 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             provideTestFollowups: (req, token) => this.proxy.$provideTestFollowups(req, token),
             executeTestFollowup: id => this.proxy.$executeTestFollowup(id),
             disposeTestFollowups: ids => this.proxy.$disposeTestFollowups(ids),
-            getTestsRelatedToCode: (uri, position, token) => this.proxy.$getTestsRelatedToCode(uri, position, token),
+            getTestsRelatedToCode: (uri, position, token) => this.proxy.$getTestsRelatedToCode(uri, position, token)
         }));
-        this._register(this.testService.onDidCancelTestRun(({ runId, taskId }) => {
+        this._register(this.testService.onDidCancelTestRun((
+            {
+                runId,
+                taskId
+            }
+        ) => {
             this.proxy.$cancelExtensionTestRun(runId, taskId);
         }));
         this._register(Event.debounce(testProfiles.onDidChange, (_last, e) => e)(() => {
             const obj = {};
-            for (const group of [TestRunProfileBitset.Run, TestRunProfileBitset.Debug, TestRunProfileBitset.Coverage]) {
+            for (const group of [
+                TestRunProfileBitset.Run,
+                TestRunProfileBitset.Debug,
+                TestRunProfileBitset.Coverage
+            ]) {
                 for (const profile of this.testProfiles.getGroupDefaultProfiles(group)) {
                     obj[profile.controllerId] ??= [];
                     obj[profile.controllerId].push(profile.profileId);
@@ -49,13 +64,12 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             this.proxy.$setDefaultRunProfiles(obj);
         }));
         this._register(resultService.onResultsChanged(evt => {
-            if ('completed' in evt) {
+            if ("completed" in evt) {
                 const serialized = evt.completed.toJSONWithMessages();
                 if (serialized) {
                     this.proxy.$publishTestResults([serialized]);
                 }
-            }
-            else if ('removed' in evt) {
+            } else if ("removed" in evt) {
                 evt.removed.forEach(r => {
                     if (r instanceof LiveTestResult) {
                         this.proxy.$disposeRun(r.id);
@@ -104,13 +118,11 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
                 let value = task.coverage.read(undefined);
                 if (!value) {
                     value = ( new TestCoverage(run, taskId, this.uriIdentityService, {
-                        getCoverageDetails: (id, testId, token) => this.proxy.$getCoverageDetails(id, testId, token)
-                            .then(r => ( r.map(CoverageDetails.deserialize))),
+                        getCoverageDetails: (id, testId, token) => this.proxy.$getCoverageDetails(id, testId, token).then(r => ( r.map(CoverageDetails.deserialize)))
                     }));
                     value.append(deserialized, tx);
                     task.coverage.set(value, tx);
-                }
-                else {
+                } else {
                     value.append(deserialized, tx);
                 }
             });
@@ -163,7 +175,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             getRelatedCode: (testId, token) => this.proxy.$getCodeRelatedToTest(testId, token).then(locations => ( locations.map(l => ({
                 uri: URI.revive(l.uri),
                 range: Range.lift(l.range)
-            })))),
+            }))))
         };
         disposable.add(toDisposable(() => this.testProfiles.removeProfile(controllerId)));
         disposable.add(this.testService.registerTestController(controllerId, controller));
@@ -207,11 +219,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         return result.id;
     }
     async $getCoverageDetails(resultId, taskIndex, uri, token) {
-        const details = await this.resultService.getResult(resultId)
-            ?.tasks[taskIndex]
-            ?.coverage.get()
-            ?.getUri(( URI.from(uri)))
-            ?.details(token);
+        const details = await this.resultService.getResult(resultId)?.tasks[taskIndex]?.coverage.get()?.getUri(( URI.from(uri)))?.details(token);
         return details || [];
     }
     dispose() {
@@ -226,12 +234,6 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         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);
+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

@@ -17,9 +17,6 @@ let MainThreadTheming = class MainThreadTheming {
         this._themeChangeListener.dispose();
     }
 };
-MainThreadTheming = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTheming),
-    ( __param(1, IThemeService))
-], MainThreadTheming);
+MainThreadTheming = __decorate([extHostNamedCustomer(MainContext.MainThreadTheming), ( __param(1, IThemeService))], MainThreadTheming);
 
 export { MainThreadTheming };

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

@@ -40,17 +40,14 @@ let MainThreadTimeline = class MainThreadTimeline {
         this._timelineService.unregisterTimelineProvider(id);
     }
     $emitTimelineChangeEvent(e) {
-        this.logService.trace(`MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`);
+        this.logService.trace(
+            `MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`
+        );
         const emitter = this._providerEmitters.get(e.id);
         emitter?.fire(e);
     }
-    dispose() {
-    }
+    dispose() {}
 };
-MainThreadTimeline = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTimeline),
-    ( __param(1, ILogService)),
-    ( __param(2, ITimelineService))
-], MainThreadTimeline);
+MainThreadTimeline = __decorate([extHostNamedCustomer(MainContext.MainThreadTimeline), ( __param(1, ILogService)), ( __param(2, ITimelineService))], MainThreadTimeline);
 
 export { MainThreadTimeline };

package/vscode/src/vs/workbench/api/browser/mainThreadTreeViews.d.ts

@@ -8,15 +8,17 @@ import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
 import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 export declare class MainThreadTreeViews extends Disposable implements MainThreadTreeViewsShape {
     private readonly viewsService;
     private readonly notificationService;
     private readonly extensionService;
     private readonly logService;
+    private readonly telemetryService;
     private readonly _proxy;
     private readonly _dataProviders;
     private readonly _dndControllers;
-    constructor(extHostContext: IExtHostContext, viewsService: IViewsService, notificationService: INotificationService, extensionService: IExtensionService, logService: ILogService);
+    constructor(extHostContext: IExtHostContext, viewsService: IViewsService, notificationService: INotificationService, extensionService: IExtensionService, logService: ILogService, telemetryService: ITelemetryService);
     $registerTreeViewDataProvider(treeViewId: string, options: {
         showCollapseAll: boolean;
         canSelectMany: boolean;
@@ -38,6 +40,7 @@ export declare class MainThreadTreeViews extends Disposable implements MainThrea
     $setBadge(treeViewId: string, badge: IViewBadge | undefined): void;
     $resolveDropFileData(destinationViewId: string, requestId: number, dataItemId: string): Promise<VSBuffer>;
     $disposeTree(treeViewId: string): Promise<void>;
+    $logResolveTreeNodeRetry(extensionId: string, retryCount: number, exhausted: boolean): void;
     private reveal;
     private registerListeners;
     private getTreeView;

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

@@ -14,26 +14,37 @@ import { VSDataTransfer, createStringDataTransferItem } from '@codingame/monaco-
 import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
 import { DataTransfer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHostTypeConverters';
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 
 let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
-    constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
+    constructor(
+        extHostContext,
+        viewsService,
+        notificationService,
+        extensionService,
+        logService,
+        telemetryService
+    ) {
         super();
         this.viewsService = viewsService;
         this.notificationService = notificationService;
         this.extensionService = extensionService;
         this.logService = logService;
+        this.telemetryService = telemetryService;
         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.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(
+            this._dataProviders.set(treeViewId, {
+                dataProvider,
+                dispose: () => disposables.dispose()
+            });
+            const dndController = (options.hasHandleDrag || options.hasHandleDrop) ? ( new TreeViewDragAndDropController(
                 treeViewId,
                 options.dropMimeTypes,
                 options.dragMimeTypes,
@@ -52,42 +63,55 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
                 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);
+            } 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(() => {
+        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 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);
+        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.items.length ? itemsToRefresh.items : undefined, itemsToRefresh.checkboxes.length ? itemsToRefresh.checkboxes : undefined);
+            return viewer.refresh(
+                itemsToRefresh.items.length ? itemsToRefresh.items : undefined,
+                itemsToRefresh.checkboxes.length ? itemsToRefresh.checkboxes : undefined
+            );
         }
         return Promise.resolve();
     }
     $setMessage(treeViewId, message) {
-        this.logService.trace('MainThreadTreeViews#$setMessage', treeViewId, ( message.toString()));
+        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);
+        this.logService.trace("MainThreadTreeViews#$setTitle", treeViewId, title, description);
         const viewer = this.getTreeView(treeViewId);
         if (viewer) {
             viewer.title = title;
@@ -95,7 +119,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         }
     }
     $setBadge(treeViewId, badge) {
-        this.logService.trace('MainThreadTreeViews#$setBadge', treeViewId, badge?.value, badge?.tooltip);
+        this.logService.trace("MainThreadTreeViews#$setBadge", treeViewId, badge?.value, badge?.tooltip);
         const viewer = this.getTreeView(treeViewId);
         if (viewer) {
             viewer.badge = badge;
@@ -104,7 +128,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
     $resolveDropFileData(destinationViewId, requestId, dataItemId) {
         const controller = this._dndControllers.get(destinationViewId);
         if (!controller) {
-            throw ( new Error('Unknown tree'));
+            throw ( new Error("Unknown tree"));
         }
         return controller.resolveDropFileData(requestId, dataItemId);
     }
@@ -115,11 +139,24 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         }
         this._dataProviders.deleteAndDispose(treeViewId);
     }
+    $logResolveTreeNodeRetry(extensionId, retryCount, exhausted) {
+        this.telemetryService.publicLog2("treeView.resolveRetry", {
+            extensionId,
+            retryCount,
+            exhausted
+        });
+    }
     async reveal(treeView, dataProvider, itemIn, parentChain, options) {
-        options = options ? options : { select: false, focus: false };
+        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);
+        let expand = Math.min(
+            isNumber(options.expand) ? options.expand : options.expand === true ? 1 : 0,
+            3
+        );
         if (dataProvider.isEmpty()) {
             await treeView.refresh();
         }
@@ -137,8 +174,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
             }
             if (focus === false) {
                 treeView.setFocus();
-            }
-            else if (focus) {
+            } else if (focus) {
                 treeView.setFocus(item);
             }
             let itemsToExpand = [item];
@@ -155,13 +191,28 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         }
     }
     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.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 };
+                return {
+                    treeItemHandle: item.handle,
+                    newState: item.checkbox?.isChecked ?? false
+                };
             })));
         }));
     }
@@ -181,13 +232,7 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         super.dispose();
     }
 };
-MainThreadTreeViews = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadTreeViews),
-    ( __param(1, IViewsService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, ILogService))
-], MainThreadTreeViews);
+MainThreadTreeViews = __decorate([extHostNamedCustomer(MainContext.MainThreadTreeViews), ( __param(1, IViewsService)), ( __param(2, INotificationService)), ( __param(3, IExtensionService)), ( __param(4, ILogService)), ( __param(5, ITelemetryService))], MainThreadTreeViews);
 class TreeViewDragAndDropController {
     constructor(treeViewId, dropMimeTypes, dragMimeTypes, hasWillDrop, _proxy) {
         this.treeViewId = treeViewId;
@@ -197,16 +242,31 @@ class TreeViewDragAndDropController {
         this._proxy = _proxy;
         this.dataTransfersCache = ( new DataTransferFileCache());
     }
-    async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
+    async handleDrop(
+        dataTransfer,
+        targetTreeItem,
+        token,
+        operationUuid,
+        sourceTreeId,
+        sourceTreeItemHandles
+    ) {
         const request = this.dataTransfersCache.add(dataTransfer);
         try {
             const dataTransferDto = await DataTransfer.fromList(dataTransfer);
             if (token.isCancellationRequested) {
                 return;
             }
-            return await this._proxy.$handleDrop(this.treeViewId, request.id, dataTransferDto, targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
-        }
-        finally {
+            return await this._proxy.$handleDrop(
+                this.treeViewId,
+                request.id,
+                dataTransferDto,
+                targetTreeItem?.handle,
+                token,
+                operationUuid,
+                sourceTreeId,
+                sourceTreeItemHandles
+            );
+        } finally {
             request.dispose();
         }
     }
@@ -244,8 +304,7 @@ class TreeViewDataProvider {
         if (!treeItems) {
             this.itemsMap.clear();
         }
-        return this._proxy.$getChildren(this.treeViewId, treeItems ? ( treeItems.map(item => item.handle)) : undefined)
-            .then(children => {
+        return this._proxy.$getChildren(this.treeViewId, treeItems ? ( treeItems.map(item => item.handle)) : undefined).then(children => {
             const convertedChildren = this.convertTransferChildren(treeItems ?? [], children);
             return this.postGetChildren(convertedChildren);
         }, err => {
@@ -279,8 +338,7 @@ class TreeViewDataProvider {
                     this.updateTreeItem(currentTreeItem, newTreeItem);
                     if (newTreeItemHandle === newTreeItem.handle) {
                         itemsToRefresh.push(currentTreeItem);
-                    }
-                    else {
+                    } else {
                         this.itemsMap.delete(newTreeItemHandle);
                         this.itemsMap.set(currentTreeItem.handle, currentTreeItem);
                         const parent = newTreeItem.parentHandle ? this.itemsMap.get(newTreeItem.parentHandle) : null;
@@ -291,7 +349,10 @@ class TreeViewDataProvider {
                 }
             }
         }
-        return { items: itemsToRefresh, checkboxes: checkboxesToRefresh };
+        return {
+            items: itemsToRefresh,
+            checkboxes: checkboxesToRefresh
+        };
     }
     getItem(treeItemHandle) {
         return this.itemsMap.get(treeItemHandle);
@@ -313,7 +374,7 @@ class TreeViewDataProvider {
                     continue;
                 }
                 for (const element of elements) {
-                    const resolvable = ( new ResolvableTreeItem(element, hasResolve ? (token) => {
+                    const resolvable = ( new ResolvableTreeItem(element, hasResolve ? token => {
                         return this._proxy.$resolve(this.treeViewId, element.handle, token);
                     } : undefined));
                     this.itemsMap.set(element.handle, resolvable);
@@ -326,8 +387,7 @@ class TreeViewDataProvider {
     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))]);
+            const properties = distinct([...( Object.keys(current instanceof ResolvableTreeItem ? current.asTreeItem() : current)), ...( Object.keys(treeItem))]);
             for (const property of properties) {
                 current[property] = treeItem[property];
             }