@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.1

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm-private.d.ts

@@ -1,4 +1,4 @@
-import { IBufferCell } from '../../../../../../../external/xterm/typings/xterm.js';
+import { IBufferCell } from '../../../../../../../external/@xterm/xterm/typings/xterm.js';
 
 /*---------------------------------------------------------------------------------------------
  *  Copyright (c) Microsoft Corporation. All rights reserved.
@@ -11,6 +11,7 @@ type XtermAttributes = Omit<IBufferCell, 'getWidth' | 'getChars' | 'getCode'> &
 
 interface IXtermCore {
 	viewport?: {
+		readonly scrollBarWidth: number;
 		_innerRefresh(): void;
 	};
 	_onData: IEventEmitter<string>;
@@ -39,7 +40,9 @@ interface IXtermCore {
 			}
 		},
 		_renderer: {
-			_renderLayers?: any[];
+			value?: {
+				_renderLayers?: any[];
+			}
 		};
 		_handleIntersectionChange: any;
 	};

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.d.ts

@@ -6,7 +6,7 @@ import { ThemeIcon } from '../../../../base/common/themables.js';
 import { URI } from '../../../../base/common/uri.js';
 import { ITerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/capabilities.js';
 import { IMergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariable.js';
-import { IShellLaunchConfig, TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalBackend, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
+import { TitleEventSource, IFixedTerminalDimensions, IProcessProperty, IProcessReadyWindowsPty, ITerminalLaunchError, TerminalLocationString, ITerminalBackend, ITerminalProfileObject } from '../../../../platform/terminal/common/terminal.js';
 import { IEnvironmentVariableInfo } from './environmentVariable.js';
 
 type FontWeight = 'normal' | 'bold' | number;
@@ -126,12 +126,6 @@ interface ITerminalConfiguration {
     smoothScrolling: boolean;
     ignoreBracketedPasteMode: boolean;
 }
-interface ITerminalConfigHelper {
-    config: ITerminalConfiguration;
-    configFontIsMonospace(): boolean;
-    getFont(): ITerminalFont;
-    showRecommendations(shellLaunchConfig: IShellLaunchConfig): void;
-}
 interface ITerminalFont {
     fontFamily: string;
     fontSize: number;
@@ -240,4 +234,4 @@ interface ITerminalStatusHoverAction {
     run: () => void;
 }
 
-export { type ConfirmOnExit, type ConfirmOnKill, type FontWeight, type IRemoteTerminalAttachTarget, type IStartExtensionTerminalRequest, type ITerminalConfigHelper, type ITerminalConfiguration, type ITerminalFont, type ITerminalProcessExtHostProxy, type ITerminalProcessInfo, type ITerminalProfiles, type ITerminalStatus, type ITerminalStatusHoverAction, ProcessState };
+export { type ConfirmOnExit, type ConfirmOnKill, type FontWeight, type IRemoteTerminalAttachTarget, type IStartExtensionTerminalRequest, type ITerminalConfiguration, type ITerminalFont, type ITerminalProcessExtHostProxy, type ITerminalProcessInfo, type ITerminalProfiles, type ITerminalStatus, type ITerminalStatusHoverAction, ProcessState };

package/vscode/src/vs/workbench/contrib/terminal/common/terminal.js

@@ -20,7 +20,9 @@ const DEFAULT_COMMANDS_TO_SKIP_SHELL = [
     "workbench.action.terminal.copyAndClearSelection" ,
     "workbench.action.terminal.copySelection" ,
     "workbench.action.terminal.copySelectionAsHtml" ,
+    "workbench.action.terminal.copyLastCommand" ,
     "workbench.action.terminal.copyLastCommandOutput" ,
+    "workbench.action.terminal.copyLastCommandAndLastCommandOutput" ,
     "workbench.action.terminal.deleteToLineStart" ,
     "workbench.action.terminal.deleteWordLeft" ,
     "workbench.action.terminal.deleteWordRight" ,

package/vscode/src/vs/workbench/contrib/testing/common/testCoverage.js

@@ -0,0 +1,115 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { ICoveredCount } from './testTypes.js';
+class TestCoverage {
+    static async load(taskId, accessor, token) {
+        const files = await accessor.provideFileCoverage(token);
+        const map = ( new ResourceMap());
+        for (const [i, file] of files.entries()) {
+            map.set(file.uri, ( new FileCoverage(file, i, accessor)));
+        }
+        return ( new TestCoverage(taskId, map));
+    }
+    get tree() {
+        return this._tree ??= this.buildCoverageTree();
+    }
+    constructor(fromTaskId, fileCoverage) {
+        this.fromTaskId = fromTaskId;
+        this.fileCoverage = fileCoverage;
+    }
+    getAllFiles() {
+        return this.fileCoverage;
+    }
+    getUri(uri) {
+        return this.fileCoverage.get(uri);
+    }
+    getComputedForUri(uri) {
+        return this.tree.find(this.treePathForUri(uri));
+    }
+    buildCoverageTree() {
+        const tree = ( new WellDefinedPrefixTree());
+        for (const file of ( this.fileCoverage.values())) {
+            tree.insert(this.treePathForUri(file.uri), file);
+        }
+        const calculateComputed = (path, node) => {
+            if (node.value) {
+                return node.value;
+            }
+            const fileCoverage = {
+                uri: this.treePathToUri(path),
+                statement: ICoveredCount.empty(),
+            };
+            if (node.children) {
+                for (const [prefix, child] of node.children) {
+                    path.push(prefix);
+                    const v = calculateComputed(path, child);
+                    path.pop();
+                    ICoveredCount.sum(fileCoverage.statement, v.statement);
+                    if (v.branch) {
+                        ICoveredCount.sum(fileCoverage.branch ??= ICoveredCount.empty(), v.branch);
+                    }
+                    if (v.function) {
+                        ICoveredCount.sum(fileCoverage.function ??= ICoveredCount.empty(), v.function);
+                    }
+                }
+            }
+            return node.value = ( new ComputedFileCoverage(fileCoverage));
+        };
+        for (const node of tree.nodes) {
+            calculateComputed([], node);
+        }
+        return tree;
+    }
+    *treePathForUri(uri) {
+        yield uri.scheme;
+        yield uri.authority;
+        yield* uri.path.split('/');
+    }
+    treePathToUri(path) {
+        return ( URI.from({ scheme: path[0], authority: path[1], path: path.slice(2).join('/') }));
+    }
+}
+class AbstractFileCoverage {
+    get tpc() {
+        let numerator = this.statement.covered;
+        let denominator = this.statement.total;
+        if (this.branch) {
+            numerator += this.branch.covered;
+            denominator += this.branch.total;
+        }
+        if (this.function) {
+            numerator += this.function.covered;
+            denominator += this.function.total;
+        }
+        return denominator === 0 ? 1 : numerator / denominator;
+    }
+    constructor(coverage) {
+        this.uri = URI.revive(coverage.uri);
+        this.statement = coverage.statement;
+        this.branch = coverage.branch;
+        this.function = coverage.function;
+    }
+}
+class ComputedFileCoverage extends AbstractFileCoverage {
+}
+class FileCoverage extends AbstractFileCoverage {
+    constructor(coverage, index, accessor) {
+        super(coverage);
+        this.index = index;
+        this.accessor = accessor;
+        this._details = coverage.details;
+    }
+    async details(token = CancellationToken.None) {
+        this._details ??= this.accessor.resolveFileCoverage(this.index, token);
+        try {
+            return await this._details;
+        }
+        catch (e) {
+            this._details = undefined;
+            throw e;
+        }
+    }
+}
+export { AbstractFileCoverage, ComputedFileCoverage, FileCoverage, TestCoverage };

package/vscode/src/vs/workbench/contrib/testing/common/testCoverageService.js

@@ -0,0 +1,74 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IViewsService } from '../../../common/views.js';
+import { ITestResultService } from './testResultService.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+const ITestCoverageService = ( createDecorator('testCoverageService'));
+let TestCoverageService = class TestCoverageService extends Disposable {
+    constructor(contextKeyService, resultService, viewsService, notificationService) {
+        super();
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.lastOpenCts = this._register(( new MutableDisposable()));
+        this.selected = observableValue('testCoverage', undefined);
+        this._isOpenKey = TestingContextKeys.isTestCoverageOpen.bindTo(contextKeyService);
+        this._register(resultService.onResultsChanged(evt => {
+            if ('completed' in evt) {
+                const coverage = evt.completed.tasks.find(t => t.coverage.get());
+                if (coverage) {
+                    this.openCoverage(coverage, false);
+                }
+            }
+            else if ('removed' in evt && this.selected.get()) {
+                const taskId = this.selected.get()?.fromTaskId;
+                if (( evt.removed.some(e => ( e.tasks.some(t => t.id === taskId))))) {
+                    this.closeCoverage();
+                }
+            }
+        }));
+    }
+    async openCoverage(task, focus = true) {
+        this.lastOpenCts.value?.cancel();
+        const cts = this.lastOpenCts.value = ( new CancellationTokenSource());
+        const getCoverage = task.coverage.get();
+        if (!getCoverage) {
+            return;
+        }
+        try {
+            const coverage = await getCoverage(cts.token);
+            this.selected.set(coverage, undefined);
+            this._isOpenKey.set(true);
+        }
+        catch (e) {
+            if (!cts.token.isCancellationRequested) {
+                this.notificationService.error(( localizeWithPath(
+                    'vs/workbench/contrib/testing/common/testCoverageService',
+                    'testCoverageError',
+                    'Failed to load test coverage: {}',
+                    String(e)
+                )));
+            }
+            return;
+        }
+        if (focus && !cts.token.isCancellationRequested) {
+            this.viewsService.openView("workbench.view.testCoverage" , true);
+        }
+    }
+    closeCoverage() {
+        this._isOpenKey.set(false);
+        this.selected.set(undefined, undefined);
+    }
+};
+TestCoverageService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, ITestResultService)),
+    ( __param(2, IViewsService)),
+    ( __param(3, INotificationService))
+], TestCoverageService));
+export { ITestCoverageService, TestCoverageService };

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -3,11 +3,11 @@ import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
 import { language } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { removeAnsiEscapeCodes } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { refreshComputedState } from './getComputedState.js';
-import { MutableObservableValue, staticObservableValue } from './observableValue.js';
 import { TestId } from './testId.js';
 import { makeEmptyCounts, terminalStatePriorities, maxPriority, statesInOrder } from './testingStates.js';
 import { TestResultItem, getMarkId } from './testTypes.js';
@@ -211,7 +211,7 @@ class LiveTestResult extends Disposable {
         }
     }
     addTask(task) {
-        this.tasks.push({ ...task, coverage: this._register(( new MutableObservableValue(undefined))), otherMessages: [], output: ( new TaskRawOutput()) });
+        this.tasks.push({ ...task, coverage: observableValue(this, undefined), otherMessages: [], output: ( new TaskRawOutput()) });
         for (const test of this.tests) {
             test.tasks.push({ duration: undefined, messages: [], state: 0  });
         }
@@ -359,7 +359,7 @@ class HydratedTestResult {
             id: task.id,
             name: task.name,
             running: false,
-            coverage: staticObservableValue(undefined),
+            coverage: observableValue(this, undefined),
             output: emptyRawOutput,
             otherMessages: []
         })));

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -1,4 +1,5 @@
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { TestId } from './testId.js';
 const testRunProfileBitsetList = [
@@ -218,6 +219,68 @@ var TestResultItem;
         retired: true,
     });
 })(TestResultItem || (TestResultItem = {})));
+var ICoveredCount;
+( (function(ICoveredCount) {
+    ICoveredCount.empty = () => ({ covered: 0, total: 0 });
+    ICoveredCount.sum = (target, src) => {
+        target.covered += src.covered;
+        target.total += src.total;
+    };
+})(ICoveredCount || (ICoveredCount = {})));
+var IFileCoverage;
+( (function(IFileCoverage) {
+    IFileCoverage.serialize = (original) => ({
+        statement: original.statement,
+        branch: original.branch,
+        function: original.function,
+        details: original.details?.map(CoverageDetails.serialize),
+        uri: original.uri.toJSON(),
+    });
+    IFileCoverage.deserialize = (serialized) => ({
+        statement: serialized.statement,
+        branch: serialized.branch,
+        function: serialized.function,
+        details: serialized.details?.map(CoverageDetails.deserialize),
+        uri: ( URI.from(serialized.uri)),
+    });
+})(IFileCoverage || (IFileCoverage = {})));
+function serializeThingWithLocation(serialized) {
+    return {
+        ...serialized,
+        location: serialized.location?.toJSON(),
+    };
+}
+function deserializeThingWithLocation(serialized) {
+    serialized.location = serialized.location ? (Position.isIPosition(serialized.location) ? Position.lift(serialized.location) : Range.lift(serialized.location)) : undefined;
+    return serialized;
+}
+const KEEP_N_LAST_COVERAGE_REPORTS = 3;
+var CoverageDetails;
+( (function(CoverageDetails) {
+    CoverageDetails.serialize = (original) => original.type === 0  ? IFunctionCoverage.serialize(original) : IStatementCoverage.serialize(original);
+    CoverageDetails.deserialize = (serialized) => serialized.type === 0  ? IFunctionCoverage.deserialize(serialized) : IStatementCoverage.deserialize(serialized);
+})(CoverageDetails || (CoverageDetails = {})));
+var IBranchCoverage;
+( (function(IBranchCoverage) {
+    IBranchCoverage.serialize = serializeThingWithLocation;
+    IBranchCoverage.deserialize = deserializeThingWithLocation;
+})(IBranchCoverage || (IBranchCoverage = {})));
+var IFunctionCoverage;
+( (function(IFunctionCoverage) {
+    IFunctionCoverage.serialize = serializeThingWithLocation;
+    IFunctionCoverage.deserialize = deserializeThingWithLocation;
+})(IFunctionCoverage || (IFunctionCoverage = {})));
+var IStatementCoverage;
+( (function(IStatementCoverage) {
+    IStatementCoverage.serialize = (original) => ({
+        ...serializeThingWithLocation(original),
+        branches: original.branches?.map(IBranchCoverage.serialize),
+    });
+    IStatementCoverage.deserialize = (serialized) => ({
+        ...deserializeThingWithLocation(serialized),
+        branches: serialized.branches?.map(IBranchCoverage.deserialize),
+    });
+})(IStatementCoverage || (IStatementCoverage = {})));
 var TestsDiffOp;
 ( (function(TestsDiffOp) {
     TestsDiffOp.deserialize = (u) => {
@@ -362,4 +425,4 @@ class AbstractIncrementalTestCollection {
         return {};
     }
 }
-export { AbstractIncrementalTestCollection, IRichLocation, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag, testRunProfileBitsetList };
+export { AbstractIncrementalTestCollection, CoverageDetails, IBranchCoverage, ICoveredCount, IFileCoverage, IFunctionCoverage, IRichLocation, IStatementCoverage, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, KEEP_N_LAST_COVERAGE_REPORTS, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag, testRunProfileBitsetList };

package/vscode/src/vs/workbench/contrib/testing/common/testingContextKeys.js

@@ -102,6 +102,15 @@ var TestingContextKeys;
             'Indicates whether any tests are present in the current editor'
         )) }
     ));
+    TestingContextKeys.isTestCoverageOpen = ( new RawContextKey(
+        'testing.isTestCoverageOpen',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isTestCoverageOpen',
+            'Indicates whether a test coverage report is open'
+        )) }
+    ));
     TestingContextKeys.capabilityToContextKey = {
         [2 ]: TestingContextKeys.hasRunnableTests,
         [8 ]: TestingContextKeys.hasCoverableTests,

package/vscode/src/vs/workbench/contrib/webview/browser/webviewWindowDragMonitor.js

@@ -1,16 +1,17 @@
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { $window } from 'monaco-editor/esm/vs/base/browser/window.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 class WebviewWindowDragMonitor extends Disposable {
     constructor(getWebview) {
         super();
-        this._register(dom.addDisposableListener(window, dom.EventType.DRAG_START, () => {
+        this._register(dom.addDisposableListener($window, dom.EventType.DRAG_START, () => {
             getWebview()?.windowDidDragStart();
         }));
         const onDragEnd = () => {
             getWebview()?.windowDidDragEnd();
         };
-        this._register(dom.addDisposableListener(window, dom.EventType.DRAG_END, onDragEnd));
-        this._register(dom.addDisposableListener(window, dom.EventType.MOUSE_MOVE, currentEvent => {
+        this._register(dom.addDisposableListener($window, dom.EventType.DRAG_END, onDragEnd));
+        this._register(dom.addDisposableListener($window, dom.EventType.MOUSE_MOVE, currentEvent => {
             if (currentEvent.buttons === 0) {
                 onDragEnd();
             }

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { $window } from 'monaco-editor/esm/vs/base/browser/window.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
@@ -12,7 +13,6 @@ import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeS
 import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
 import { WebviewWindowDragMonitor } from '../../webview/browser/webviewWindowDragMonitor.js';
 import { WebviewInput } from './webviewEditorInput.js';
-import { IEditorDropService } from '../../../services/editor/browser/editorDropService.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IHostService } from '../../../services/host/browser/host.js';
@@ -30,11 +30,11 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
     static { WebviewEditor_1 = this; }
     static { this.ID = 'WebviewEditor'; }
     get onDidFocus() { return this._onDidFocusWebview.event; }
-    constructor(telemetryService, themeService, storageService, editorGroupsService, _editorService, _workbenchLayoutService, _editorDropService, _hostService, _contextKeyService) {
+    constructor(telemetryService, themeService, storageService, _editorGroupsService, _editorService, _workbenchLayoutService, _hostService, _contextKeyService) {
         super(WebviewEditor_1.ID, telemetryService, themeService, storageService);
+        this._editorGroupsService = _editorGroupsService;
         this._editorService = _editorService;
         this._workbenchLayoutService = _workbenchLayoutService;
-        this._editorDropService = _editorDropService;
         this._hostService = _hostService;
         this._contextKeyService = _contextKeyService;
         this._visible = false;
@@ -43,7 +43,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         this._onFocusWindowHandler = this._register(( new MutableDisposable()));
         this._onDidFocusWebview = this._register(( new Emitter()));
         this._scopedContextKeyService = this._register(( new MutableDisposable()));
-        this._register(Event.any(editorGroupsService.onDidScroll, editorGroupsService.onDidAddGroup, editorGroupsService.onDidRemoveGroup, editorGroupsService.onDidMoveGroup)(() => {
+        this._register(Event.any(_editorGroupsService.activePart.onDidScroll, _editorGroupsService.activePart.onDidAddGroup, _editorGroupsService.activePart.onDidRemoveGroup, _editorGroupsService.activePart.onDidMoveGroup)(() => {
             if (this.webview && this._visible) {
                 this.synchronizeWebviewContainerDimensions(this.webview);
             }
@@ -136,7 +136,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
             dom.setParentFlowTo(input.webview.container, this._element);
         }
         this._webviewVisibleDisposables.clear();
-        this._webviewVisibleDisposables.add(this._editorDropService.createEditorDropTarget(input.webview.container, {
+        this._webviewVisibleDisposables.add(this._editorGroupsService.createEditorDropTarget(input.webview.container, {
             containsGroup: (group) => this.group?.id === group.id
         }));
         this._webviewVisibleDisposables.add(( new WebviewWindowDragMonitor(() => this.webview)));
@@ -147,7 +147,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         if (!this._element?.isConnected) {
             return;
         }
-        const rootContainer = this._workbenchLayoutService.getContainer("workbench.parts.editor" );
+        const rootContainer = this._workbenchLayoutService.getContainer($window, "workbench.parts.editor" );
         webview.layoutWebviewOverElement(this._element.parentElement, dimension, rootContainer);
     }
     trackFocus(webview) {
@@ -166,8 +166,7 @@ WebviewEditor = WebviewEditor_1 = ( __decorate([
     ( __param(3, IEditorGroupsService)),
     ( __param(4, IEditorService)),
     ( __param(5, IWorkbenchLayoutService)),
-    ( __param(6, IEditorDropService)),
-    ( __param(7, IHostService)),
-    ( __param(8, IContextKeyService))
+    ( __param(6, IHostService)),
+    ( __param(7, IContextKeyService))
 ], WebviewEditor));
 export { CONTEXT_ACTIVE_WEBVIEW_PANEL_ID, WebviewEditor };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput.js

@@ -11,7 +11,7 @@ class WebviewInput extends EditorInput {
         return this.viewType;
     }
     get capabilities() {
-        return 2  | 8  | 128 ;
+        return 2  | 8  | 128  | 1024 ;
     }
     get resource() {
         return ( URI.from({

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewIconManager.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
 let WebviewIconManager = class WebviewIconManager {
@@ -14,12 +15,14 @@ let WebviewIconManager = class WebviewIconManager {
         });
     }
     dispose() {
-        this._styleElement?.remove();
+        this._styleElementDisposable?.dispose();
+        this._styleElementDisposable = undefined;
         this._styleElement = undefined;
     }
     get styleElement() {
         if (!this._styleElement) {
-            this._styleElement = dom.createStyleSheet();
+            this._styleElementDisposable = ( new DisposableStore());
+            this._styleElement = dom.createStyleSheet(undefined, undefined, this._styleElementDisposable);
             this._styleElement.className = 'webview-icons';
         }
         return this._styleElement;

package/vscode/src/vs/workbench/services/activity/browser/activityService.d.ts

@@ -1,20 +1,26 @@
 import { IActivityService, IActivity } from '../common/activity.js';
-import { IDisposable } from '../../../../base/common/lifecycle.js';
-import { IViewDescriptorService } from '../../../common/views.js';
+import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
+import { ViewContainer, IViewDescriptorService } from '../../../common/views.js';
+import { Event } from '../../../../base/common/event.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
 
-declare class ActivityService implements IActivityService {
-    private readonly paneCompositeService;
+declare class ActivityService extends Disposable implements IActivityService {
     private readonly viewDescriptorService;
     private readonly instantiationService;
     _serviceBrand: undefined;
-    private viewActivities;
-    constructor(paneCompositeService: IPaneCompositePartService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
-    showViewContainerActivity(viewContainerId: string, { badge, clazz, priority }: IActivity): IDisposable;
+    private readonly viewActivities;
+    private readonly _onDidChangeActivity;
+    readonly onDidChangeActivity: Event<string | ViewContainer>;
+    private readonly viewContainerActivities;
+    private readonly globalActivities;
+    constructor(viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
+    showViewContainerActivity(viewContainerId: string, activity: IActivity): IDisposable;
+    getViewContainerActivities(viewContainerId: string): IActivity[];
     showViewActivity(viewId: string, activity: IActivity): IDisposable;
-    showAccountsActivity({ badge, clazz, priority }: IActivity): IDisposable;
-    showGlobalActivity({ badge, clazz, priority }: IActivity): IDisposable;
+    showAccountsActivity(activity: IActivity): IDisposable;
+    showGlobalActivity(activity: IActivity): IDisposable;
+    getActivity(id: string): IActivity[];
+    private showActivity;
 }
 
 export { ActivityService };

package/vscode/src/vs/workbench/services/activity/common/activity.d.ts

@@ -1,18 +1,27 @@
 import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { Event } from '../../../../base/common/event.js';
+import { ViewContainer } from '../../../common/views.js';
 
 interface IActivity {
     readonly badge: IBadge;
-    readonly clazz?: string;
     readonly priority?: number;
 }
 declare const IActivityService: ServiceIdentifier<IActivityService>;
 interface IActivityService {
     readonly _serviceBrand: undefined;
+    /**
+     * Emitted when activity changes for a view container or when the activity of the global actions change.
+     */
+    readonly onDidChangeActivity: Event<string | ViewContainer>;
     /**
      * Show activity for the given view container
      */
     showViewContainerActivity(viewContainerId: string, badge: IActivity): IDisposable;
+    /**
+     * Returns the activity for the given view container
+     */
+    getViewContainerActivities(viewContainerId: string): IActivity[];
     /**
      * Show activity for the given view
      */
@@ -25,6 +34,10 @@ interface IActivityService {
      * Show global activity
      */
     showGlobalActivity(activity: IActivity): IDisposable;
+    /**
+     * Return the activity for the given action
+     */
+    getActivity(id: string): IActivity[];
 }
 interface IBadge {
     getDescription(): string;

package/vscode/src/vs/workbench/services/activity/common/activity.js

@@ -19,12 +19,6 @@ class NumberBadge extends BaseBadge {
         return this.descriptorFn(this.number);
     }
 }
-class TextBadge extends BaseBadge {
-    constructor(text, descriptorFn) {
-        super(descriptorFn);
-        this.text = text;
-    }
-}
 class IconBadge extends BaseBadge {
     constructor(icon, descriptorFn) {
         super(descriptorFn);
@@ -33,4 +27,4 @@ class IconBadge extends BaseBadge {
 }
 class ProgressBadge extends BaseBadge {
 }
-export { IActivityService, IconBadge, NumberBadge, ProgressBadge, TextBadge };
+export { IActivityService, IconBadge, NumberBadge, ProgressBadge };