@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/api/common/extHostTestItem.js

@@ -110,7 +110,7 @@ const toItemFromContext = (context) => {
 class TestItemImpl {
     constructor(controllerId, id, label, uri) {
         if (id.includes("\0" )) {
-            throw new Error(`Test IDs may not include the ${JSON.stringify(id)} symbol`);
+            throw ( new Error(`Test IDs may not include the ${JSON.stringify(id)} symbol`));
         }
         const api = createPrivateApiFor(this, controllerId);
         Object.defineProperties(this, {

package/vscode/src/vs/workbench/api/common/extHostTesting.js

@@ -68,7 +68,7 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
     }
     createTestController(extension, controllerId, label, refreshHandler) {
         if (( this.controllers.has(controllerId))) {
-            throw new Error(`Attempt to insert a duplicate controller with ID "${controllerId}"`);
+            throw ( new Error(`Attempt to insert a duplicate controller with ID "${controllerId}"`));
         }
         const disposable = ( new DisposableStore());
         const collection = disposable.add(( new ExtHostTestItemCollection(controllerId, label, this.editors)));
@@ -155,14 +155,14 @@ let ExtHostTesting = class ExtHostTesting extends Disposable {
     async runTests(req, token = CancellationToken.None) {
         const profile = tryGetProfileFromTestRunReq(req);
         if (!profile) {
-            throw new Error('The request passed to `vscode.test.runTests` must include a profile');
+            throw ( new Error('The request passed to `vscode.test.runTests` must include a profile'));
         }
         const controller = this.controllers.get(profile.controllerId);
         if (!controller) {
-            throw new Error('Controller not found');
+            throw ( new Error('Controller not found'));
         }
         await this.proxy.$runTests({
-            isUiTriggered: false,
+            preserveFocus: req.preserveFocus ?? true,
             targets: [{
                     testIds: req.include?.map(t => ( TestId.fromExtHostTestItem(t, controller.collection.root.id).toString())) ?? [controller.collection.root.id],
                     profileGroup: profileGroupToBitset[profile.kind],
@@ -339,18 +339,15 @@ class TestRunTracker extends Disposable {
     }
     getCoverageDetails(id, token) {
         const [, taskId, covId] = TestId.fromString(id).path;
-        const obj = this.publishedCoverage.get(covId);
-        if (!obj) {
+        const coverage = this.publishedCoverage.get(covId);
+        if (!coverage) {
             return [];
         }
-        if (obj.backCompatResolve) {
-            return obj.backCompatResolve(token);
-        }
         const task = this.tasks.get(taskId);
         if (!task) {
-            throw new Error('unreachable: run task was not found');
+            throw ( new Error('unreachable: run task was not found'));
         }
-        return this.profile?.loadDetailedCoverage?.(task.run, obj.coverage, token) ?? [];
+        return this.profile?.loadDetailedCoverage?.(task.run, coverage, token) ?? [];
     }
     createRun(name) {
         const runId = this.dto.id;
@@ -379,34 +376,18 @@ class TestRunTracker extends Disposable {
             }
             this.proxy.$appendTestMessagesInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), converted);
         };
-        const addCoverage = (coverage, backCompatResolve) => {
-            const uriStr = ( coverage.uri.toString());
-            const id = ( ( new TestId([runId, taskId, uriStr])).toString());
-            this.publishedCoverage.set(uriStr, { coverage, backCompatResolve });
-            this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(id, coverage));
-        };
         let ended = false;
-        let coverageProvider;
         const run = {
             isPersisted: this.dto.isPersisted,
             token: this.cts.token,
             name,
             onDidDispose: this.onDidDispose,
-            get coverageProvider() {
-                return coverageProvider;
+            addCoverage: coverage => {
+                const uriStr = ( coverage.uri.toString());
+                const id = ( ( new TestId([runId, taskId, uriStr])).toString());
+                this.publishedCoverage.set(uriStr, coverage);
+                this.proxy.$appendCoverage(runId, taskId, TestCoverage.fromFile(id, coverage));
             },
-            set coverageProvider(provider) {
-                coverageProvider = provider;
-                if (provider) {
-                    Promise.resolve(provider.provideFileCoverage(CancellationToken.None)).then(coverage => {
-                        coverage?.forEach(c => addCoverage(c, provider.resolveFileCoverage && (async (token) => {
-                            const r = await provider.resolveFileCoverage(c, token);
-                            return (r || c).detailedCoverage;
-                        })));
-                    });
-                }
-            },
-            addCoverage,
             enqueued: guardTestMutation(test => {
                 this.proxy.$updateTestStateInRun(runId, taskId, ( TestId.fromExtHostTestItem(test, ctrlId).toString()), 1 );
             }),
@@ -470,7 +451,7 @@ class TestRunTracker extends Disposable {
     }
     ensureTestIsKnown(test) {
         if (!(test instanceof TestItemImpl)) {
-            throw new InvalidTestItemError(test.id);
+            throw ( new InvalidTestItemError(test.id));
         }
         if (( this.sharedTestIds.has(( TestId.fromExtHostTestItem(test, this.dto.controllerId).toString())))) {
             return;
@@ -544,6 +525,7 @@ class TestRunCoordinator {
             exclude: request.exclude?.map(t => ( TestId.fromExtHostTestItem(t, collection.root.id).toString())) ?? [],
             id: dto.id,
             include: request.include?.map(t => ( TestId.fromExtHostTestItem(t, collection.root.id).toString())) ?? [collection.root.id],
+            preserveFocus: request.preserveFocus ?? true,
             persist
         });
         const tracker = this.getTracker(request, dto, request.profile);
@@ -564,7 +546,9 @@ const tryGetProfileFromTestRunReq = (request) => {
         return undefined;
     }
     if (!(request.profile instanceof TestRunProfileImpl)) {
-        throw new Error(`TestRunRequest.profile is not an instance created from TestController.createRunProfile`);
+        throw ( new Error(
+            `TestRunRequest.profile is not an instance created from TestController.createRunProfile`
+        ));
     }
     return request.profile;
 };
@@ -798,7 +782,7 @@ class TestRunProfileImpl {
         profiles.set(profileId, this);
         const groupBitset = profileGroupToBitset[kind];
         if (typeof groupBitset !== 'number') {
-            throw new Error(`Unknown TestRunProfile.group ${kind}`);
+            throw ( new Error(`Unknown TestRunProfile.group ${kind}`));
         }
         if (_isDefault) {
             activeProfiles.add(profileId);

package/vscode/src/vs/workbench/api/common/extHostTestingPrivateApi.js

@@ -8,7 +8,7 @@ const createPrivateApiFor = (impl, controllerId) => {
 const getPrivateApiFor = (impl) => {
     const api = eventPrivateApis.get(impl);
     if (!api) {
-        throw new InvalidTestItemError(impl?.id || '<unknown>');
+        throw ( new InvalidTestItemError(impl?.id || '<unknown>'));
     }
     return api;
 };

package/vscode/src/vs/workbench/api/common/extHostTextEditor.js

@@ -38,7 +38,7 @@ class TextEditorEdit {
     }
     _throwIfFinalized() {
         if (this._finalized) {
-            throw new Error('Edit is only valid while callback runs');
+            throw ( new Error('Edit is only valid while callback runs'));
         }
     }
     replace(location, value) {
@@ -51,7 +51,7 @@ class TextEditorEdit {
             range = location;
         }
         else {
-            throw new Error('Unrecognized location');
+            throw ( new Error('Unrecognized location'));
         }
         this._pushEdit(range, value, false);
     }
@@ -66,7 +66,7 @@ class TextEditorEdit {
             range = location;
         }
         else {
-            throw new Error('Unrecognized location');
+            throw ( new Error('Unrecognized location'));
         }
         this._pushEdit(range, null, true);
     }
@@ -317,7 +317,7 @@ class ExtHostTextEditor {
                 return document.value;
             },
             set document(_value) {
-                throw new ReadonlyError('document');
+                throw ( new ReadonlyError('document'));
             },
             get selection() {
                 return that._selections && that._selections[0];
@@ -343,7 +343,7 @@ class ExtHostTextEditor {
                 return that._visibleRanges;
             },
             set visibleRanges(_value) {
-                throw new ReadonlyError('visibleRanges');
+                throw ( new ReadonlyError('visibleRanges'));
             },
             get options() {
                 return that._options.value;
@@ -357,7 +357,7 @@ class ExtHostTextEditor {
                 return that._viewColumn;
             },
             set viewColumn(_value) {
-                throw new ReadonlyError('viewColumn');
+                throw ( new ReadonlyError('viewColumn'));
             },
             edit(callback, options = { undoStopBefore: true, undoStopAfter: true }) {
                 if (that._disposed) {

package/vscode/src/vs/workbench/api/common/extHostTextEditors.js

@@ -59,10 +59,10 @@ class ExtHostEditors {
             return editor.value;
         }
         if (editorId) {
-            throw new Error(`Could NOT open editor for "${document.uri.toString()}" because another editor opened in the meantime.`);
+            throw ( new Error(`Could NOT open editor for "${( document.uri.toString())}" because another editor opened in the meantime.`));
         }
         else {
-            throw new Error(`Could NOT open editor for "${document.uri.toString()}".`);
+            throw ( new Error(`Could NOT open editor for "${( document.uri.toString())}".`));
         }
     }
     createTextEditorDecorationType(extension, options) {
@@ -71,7 +71,7 @@ class ExtHostEditors {
     $acceptEditorPropertiesChanged(id, data) {
         const textEditor = this._extHostDocumentsAndEditors.getEditor(id);
         if (!textEditor) {
-            throw new Error('unknown text editor');
+            throw ( new Error('unknown text editor'));
         }
         if (data.options) {
             textEditor._acceptOptions(data.options);
@@ -111,7 +111,7 @@ class ExtHostEditors {
         for (const id in data) {
             const textEditor = this._extHostDocumentsAndEditors.getEditor(id);
             if (!textEditor) {
-                throw new Error('Unknown text editor');
+                throw ( new Error('Unknown text editor'));
             }
             const viewColumn = ViewColumn.to(data[id]);
             if (textEditor.value.viewColumn !== viewColumn) {

package/vscode/src/vs/workbench/api/common/extHostTimeline.js

@@ -135,7 +135,7 @@ class ExtHostTimeline {
     registerTimelineProviderCore(provider, extension) {
         const existing = this._providers.get(provider.id);
         if (existing) {
-            throw new Error(`Timeline Provider ${provider.id} already exists.`);
+            throw ( new Error(`Timeline Provider ${provider.id} already exists.`));
         }
         this._proxy.$registerTimelineProvider({
             id: provider.id,

package/vscode/src/vs/workbench/api/common/extHostTreeViews.js

@@ -13,6 +13,7 @@ import { isMarkdownString } from '../../../base/common/htmlContent.js';
 import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { TreeViewsDnDService } from '../../../editor/common/services/treeViewsDnd.js';
 import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+const _moduleId = "vs/workbench/api/common/extHostTreeViews";
 function toTreeItemLabel(label, extension) {
     if (isString(label)) {
         return { label };
@@ -63,7 +64,7 @@ class ExtHostTreeViews extends Disposable {
     }
     createTreeView(viewId, options, extension) {
         if (!options || !options.treeDataProvider) {
-            throw new Error('Options with treeDataProvider is mandatory');
+            throw ( new Error('Options with treeDataProvider is mandatory'));
         }
         const dropMimeTypes = options.dragAndDropController?.dropMimeTypes ?? [];
         const dragMimeTypes = options.dragAndDropController?.dragMimeTypes ?? [];
@@ -183,28 +184,28 @@ class ExtHostTreeViews extends Disposable {
     async $hasResolve(treeViewId) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
-            throw new NoTreeViewError(treeViewId);
+            throw ( new NoTreeViewError(treeViewId));
         }
         return treeView.hasResolve;
     }
     $resolve(treeViewId, treeItemHandle, token) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
-            throw new NoTreeViewError(treeViewId);
+            throw ( new NoTreeViewError(treeViewId));
         }
         return treeView.resolveTreeItem(treeItemHandle, token);
     }
     $setExpanded(treeViewId, treeItemHandle, expanded) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
-            throw new NoTreeViewError(treeViewId);
+            throw ( new NoTreeViewError(treeViewId));
         }
         treeView.setExpanded(treeItemHandle, expanded);
     }
     $setSelectionAndFocus(treeViewId, selectedHandles, focusedHandle) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
-            throw new NoTreeViewError(treeViewId);
+            throw ( new NoTreeViewError(treeViewId));
         }
         treeView.setSelectionAndFocus(selectedHandles, focusedHandle);
     }
@@ -214,14 +215,14 @@ class ExtHostTreeViews extends Disposable {
             if (!isVisible) {
                 return;
             }
-            throw new NoTreeViewError(treeViewId);
+            throw ( new NoTreeViewError(treeViewId));
         }
         treeView.setVisible(isVisible);
     }
     $changeCheckboxState(treeViewId, checkboxUpdate) {
         const treeView = this.treeViews.get(treeViewId);
         if (!treeView) {
-            throw new NoTreeViewError(treeViewId);
+            throw ( new NoTreeViewError(treeViewId));
         }
         treeView.setCheckboxState(checkboxUpdate);
     }
@@ -297,7 +298,12 @@ class ExtHostTreeView extends Disposable {
         this.dataProvider = options.treeDataProvider;
         this.dndController = options.dragAndDropController;
         if (this.dataProvider.onDidChangeTreeData) {
-            this._register(this.dataProvider.onDidChangeTreeData(elementOrElements => this._onDidChangeData.fire({ message: false, element: elementOrElements })));
+            this._register(this.dataProvider.onDidChangeTreeData(elementOrElements => {
+                if (Array.isArray(elementOrElements) && elementOrElements.length === 0) {
+                    return;
+                }
+                this._onDidChangeData.fire({ message: false, element: elementOrElements });
+            }));
         }
         let refreshingPromise;
         let promiseCallback;
@@ -531,7 +537,9 @@ class ExtHostTreeView extends Disposable {
                     return Promise.resolve(node);
                 }
             }
-            throw new Error(`Cannot resolve tree item for element ${handle} from extension ${this.extension.identifier.value}`);
+            throw ( new Error(
+                `Cannot resolve tree item for element ${handle} from extension ${this.extension.identifier.value}`
+            ));
         }));
     }
     getChildrenNodes(parentNodeOrHandle) {
@@ -649,7 +657,9 @@ class ExtHostTreeView extends Disposable {
     createAndRegisterTreeNode(element, extTreeItem, parentNode) {
         const node = this.createTreeNode(element, extTreeItem, parentNode);
         if (extTreeItem.id && ( this.elements.has(node.item.handle))) {
-            throw new Error(localizeWithPath('vs/workbench/api/common/extHostTreeViews', 'treeView.duplicateElement', 'Element with id {0} is already registered', extTreeItem.id));
+            throw ( new Error(
+                localizeWithPath(_moduleId, 0, 'Element with id {0} is already registered', extTreeItem.id)
+            ));
         }
         this.addNodeToCache(element, node);
         this.addNodeToParentCache(node, parentNode);
@@ -683,7 +693,9 @@ class ExtHostTreeView extends Disposable {
     }
     validateTreeItem(extensionTreeItem) {
         if (!TreeItem.isTreeItem(extensionTreeItem, this.extension)) {
-            throw new Error(`Extension ${this.extension.identifier.value} has provided an invalid tree item.`);
+            throw ( new Error(
+                `Extension ${this.extension.identifier.value} has provided an invalid tree item.`
+            ));
         }
     }
     createTreeNode(element, extensionTreeItem, parent) {

package/vscode/src/vs/workbench/api/common/extHostTunnelService.js

@@ -10,10 +10,11 @@ import { MainContext } from './extHost.protocol.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { Disposable as Disposable$1 } from './extHostTypes.js';
+const _moduleId = "vs/workbench/api/common/extHostTunnelService";
 class ExtensionTunnel extends DisposableTunnel {
 }
 var TunnelDtoConverter;
-( (function(TunnelDtoConverter) {
+( ((function(TunnelDtoConverter) {
     function fromApiTunnel(tunnel) {
         return {
             remoteAddress: tunnel.remoteAddress,
@@ -37,27 +38,27 @@ var TunnelDtoConverter;
         };
     }
     TunnelDtoConverter.fromServiceTunnel = fromServiceTunnel;
-})(TunnelDtoConverter || (TunnelDtoConverter = {})));
-const IExtHostTunnelService = ( createDecorator('IExtHostTunnelService'));
+})(TunnelDtoConverter || (TunnelDtoConverter = {}))));
+const IExtHostTunnelService = ( (createDecorator('IExtHostTunnelService')));
 let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
     constructor(extHostRpc, initData, logService) {
         super();
         this.logService = logService;
         this._showCandidatePort = () => { return Promise.resolve(true); };
-        this._extensionTunnels = ( new Map());
-        this._onDidChangeTunnels = ( new Emitter());
+        this._extensionTunnels = ( (new Map()));
+        this._onDidChangeTunnels = ( (new Emitter()));
         this.onDidChangeTunnels = this._onDidChangeTunnels.event;
         this._providerHandleCounter = 0;
-        this._portAttributesProviders = ( new Map());
-        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadTunnelService));
+        this._portAttributesProviders = ( (new Map()));
+        this._proxy = ( (extHostRpc.getProxy(MainContext.MainThreadTunnelService)));
     }
     async openTunnel(extension, forward) {
         this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) ${extension.identifier.value} called openTunnel API for ${forward.remoteAddress.host}:${forward.remoteAddress.port}.`);
         const tunnel = await this._proxy.$openTunnel(forward, extension.displayName);
         if (tunnel) {
-            const disposableTunnel = ( new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
+            const disposableTunnel = ( (new ExtensionTunnel(tunnel.remoteAddress, tunnel.localAddress, () => {
                 return this._proxy.$closeTunnel(tunnel.remoteAddress);
-            }));
+            })));
             this._register(disposableTunnel);
             return disposableTunnel;
         }
@@ -88,7 +89,7 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
             if (!provider) {
                 return [];
             }
-            providedAttributes.push(...(await Promise.all(( ports.map(async (port) => {
+            providedAttributes.push(...(await Promise.all(( (ports.map(async (port) => {
                 let providedAttributes;
                 try {
                     providedAttributes = await provider.provider.providePortAttributes({ port, pid, commandLine }, cancellationToken);
@@ -97,20 +98,22 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                     providedAttributes = await provider.provider.providePortAttributes(port, pid, commandLine, cancellationToken);
                 }
                 return { providedAttributes, port };
-            })))));
+            }))))));
         }
         const allAttributes = providedAttributes.filter(attribute => !!attribute.providedAttributes);
-        return (allAttributes.length > 0) ? ( allAttributes.map(attributes => {
+        return (allAttributes.length > 0) ? ( (allAttributes.map(attributes => {
             return {
                 autoForwardAction: attributes.providedAttributes.autoForwardAction,
                 port: attributes.port
             };
-        })) : [];
+        }))) : [];
     }
     async $registerCandidateFinder(_enable) { }
     registerTunnelProvider(provider, information) {
         if (this._forwardPortProvider) {
-            throw new Error('A tunnel provider has already been registered. Only the first tunnel provider to be registered will be used.');
+            throw ( (new Error(
+                'A tunnel provider has already been registered. Only the first tunnel provider to be registered will be used.'
+            )));
         }
         this._forwardPortProvider = async (tunnelOptions, tunnelCreationOptions) => {
             const result = await provider.provideTunnel(tunnelOptions, tunnelCreationOptions, CancellationToken.None);
@@ -144,20 +147,12 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                     privacyOptions = [
                         {
                             id: 'private',
-                            label: ( localizeWithPath(
-                                'vs/workbench/api/common/extHostTunnelService',
-                                'tunnelPrivacy.private',
-                                "Private"
-                            )),
+                            label: ( localizeWithPath(_moduleId, 0, "Private")),
                             themeIcon: 'lock'
                         },
                         {
                             id: 'public',
-                            label: ( localizeWithPath(
-                                'vs/workbench/api/common/extHostTunnelService',
-                                'tunnelPrivacy.public',
-                                "Public"
-                            )),
+                            label: ( localizeWithPath(_moduleId, 1, "Public")),
                             themeIcon: 'eye'
                         }
                     ];
@@ -182,9 +177,9 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
         return undefined;
     }
     async $closeTunnel(remote, silent) {
-        if (( this._extensionTunnels.has(remote.host))) {
+        if (( (this._extensionTunnels.has(remote.host)))) {
             const hostMap = this._extensionTunnels.get(remote.host);
-            if (( hostMap.has(remote.port))) {
+            if (( (hostMap.has(remote.port)))) {
                 if (silent) {
                     hostMap.get(remote.port).disposeListener.dispose();
                 }
@@ -209,8 +204,8 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
                         this.logService.error('ForwardedPorts: (ExtHostTunnelService) Resolved tunnel is undefined');
                         return undefined;
                     }
-                    if (!( this._extensionTunnels.has(tunnelOptions.remoteAddress.host))) {
-                        this._extensionTunnels.set(tunnelOptions.remoteAddress.host, ( new Map()));
+                    if (!( (this._extensionTunnels.has(tunnelOptions.remoteAddress.host)))) {
+                        this._extensionTunnels.set(tunnelOptions.remoteAddress.host, ( (new Map())));
                     }
                     const disposeListener = this._register(tunnel.onDidDispose(() => {
                         this.logService.trace('ForwardedPorts: (ExtHostTunnelService) Extension fired tunnel\'s onDidDispose.');
@@ -233,17 +228,17 @@ let ExtHostTunnelService = class ExtHostTunnelService extends Disposable {
         return undefined;
     }
     async $applyCandidateFilter(candidates) {
-        const filter = await Promise.all(( candidates.map(
+        const filter = await Promise.all(( (candidates.map(
             candidate => this._showCandidatePort(candidate.host, candidate.port, candidate.detail ?? '')
-        )));
+        ))));
         const result = candidates.filter((candidate, index) => filter[index]);
-        this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) filtered from ${( candidates.map(port => port.port)).join(', ')} to ${( result.map(port => port.port)).join(', ')}`);
+        this.logService.trace(`ForwardedPorts: (ExtHostTunnelService) filtered from ${( (candidates.map(port => port.port))).join(', ')} to ${( (result.map(port => port.port))).join(', ')}`);
         return result;
     }
 };
-ExtHostTunnelService = ( __decorate([
-    ( __param(0, IExtHostRpcService)),
-    ( __param(1, IExtHostInitDataService)),
-    ( __param(2, ILogService))
-], ExtHostTunnelService));
+ExtHostTunnelService = ( (__decorate([
+    ( (__param(0, IExtHostRpcService))),
+    ( (__param(1, IExtHostInitDataService))),
+    ( (__param(2, ILogService)))
+], ExtHostTunnelService)));
 export { ExtHostTunnelService, IExtHostTunnelService, TunnelDtoConverter };