@codingame/monaco-vscode-api 2.2.2 → 3.1.0

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.js';
@@ -10,14 +10,17 @@ import { ITestService } from './testService.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { TestId } from './testId.js';
 import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+import { ITestProfileService } from './testProfileService.js';
+import { equals } from '../../../../base/common/arrays.js';
 const ITestingContinuousRunService = ( createDecorator('testingContinuousRunService'));
 let TestingContinuousRunService = class TestingContinuousRunService extends Disposable {
     get lastRunProfileIds() {
         return this.lastRun.get(( new Set()));
     }
-    constructor(testService, storageService, contextKeyService) {
+    constructor(testService, storageService, contextKeyService, testProfileService) {
         super();
         this.testService = testService;
+        this.testProfileService = testProfileService;
         this.changeEmitter = ( new Emitter());
         this.running = ( new WellDefinedPrefixTree());
         this.onDidChange = this.changeEmitter.event;
@@ -53,40 +56,61 @@ let TestingContinuousRunService = class TestingContinuousRunService extends Disp
     isEnabled() {
         return !!this.globallyRunning || this.running.size > 0;
     }
-    start(profile, testId) {
+    start(profiles, testId) {
+        const store = ( new DisposableStore());
         const cts = ( new CancellationTokenSource());
+        store.add(toDisposable(() => cts.dispose(true)));
         if (testId === undefined) {
             this.isGloballyOn.set(true);
         }
         if (!testId) {
-            this.globallyRunning?.dispose(true);
-            this.globallyRunning = cts;
+            this.globallyRunning?.dispose();
+            this.globallyRunning = store;
         }
         else {
             this.running.mutate(TestId.fromString(testId).path, c => {
-                c?.dispose(true);
-                return cts;
+                c?.dispose();
+                return store;
             });
         }
-        this.lastRun.store(( new Set(( profile.map(p => p.profileId)))));
-        this.testService.startContinuousRun({
-            continuous: true,
-            targets: ( profile.map(p => ({
-                testIds: [testId ?? p.controllerId],
-                controllerId: p.controllerId,
-                profileGroup: p.group,
-                profileId: p.profileId
-            }))),
-        }, cts.token);
+        let actualProfiles;
+        if (profiles instanceof Array) {
+            actualProfiles = profiles;
+        }
+        else {
+            const getRelevant = () => this.testProfileService.getGroupDefaultProfiles(profiles)
+                .filter(p => p.supportsContinuousRun && (!testId || TestId.root(testId) === p.controllerId));
+            actualProfiles = getRelevant();
+            store.add(this.testProfileService.onDidChange(() => {
+                if (!equals(getRelevant(), actualProfiles)) {
+                    this.start(profiles, testId);
+                }
+            }));
+        }
+        this.lastRun.store(( new Set(( actualProfiles.map(p => p.profileId)))));
+        if (actualProfiles.length) {
+            this.testService.startContinuousRun({
+                continuous: true,
+                targets: ( actualProfiles.map(p => ({
+                    testIds: [testId ?? p.controllerId],
+                    controllerId: p.controllerId,
+                    profileGroup: p.group,
+                    profileId: p.profileId
+                }))),
+            }, cts.token);
+        }
         this.changeEmitter.fire(testId);
     }
     stop(testId) {
         if (!testId) {
-            this.globallyRunning?.dispose(true);
+            this.globallyRunning?.dispose();
             this.globallyRunning = undefined;
         }
         else {
-            this.running.delete(TestId.fromString(testId).path)?.dispose(true);
+            const cancellations = [...this.running.deleteRecursive(TestId.fromString(testId).path)];
+            for (let i = cancellations.length - 1; i >= 0; i--) {
+                cancellations[i].dispose();
+            }
         }
         if (testId === undefined) {
             this.isGloballyOn.set(false);
@@ -97,6 +121,7 @@ let TestingContinuousRunService = class TestingContinuousRunService extends Disp
 TestingContinuousRunService = ( __decorate([
     ( __param(0, ITestService)),
     ( __param(1, IStorageService)),
-    ( __param(2, IContextKeyService))
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ITestProfileService))
 ], TestingContinuousRunService));
 export { ITestingContinuousRunService, TestingContinuousRunService };

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

@@ -1,2 +1,3 @@
 const ShowCurrentReleaseNotesActionId = 'update.showCurrentReleaseNotes';
-export { ShowCurrentReleaseNotesActionId };
+const ShowCurrentReleaseNotesFromCurrentFileActionId = 'developer.showCurrentFileAsReleaseNotes';
+export { ShowCurrentReleaseNotesActionId, ShowCurrentReleaseNotesFromCurrentFileActionId };

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

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { isFirefox } from '../../../../base/browser/browser.js';
 import { addDisposableListener, getActiveWindow, EventType } from '../../../../base/browser/dom.js';
-import { ThrottledDelayer } from '../../../../base/common/async.js';
+import { ThrottledDelayer, promiseWithResolvers } from '../../../../base/common/async.js';
 import { streamToBuffer } from '../../../../base/common/buffer.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
@@ -285,9 +285,8 @@ let WebviewElement = class WebviewElement extends Disposable {
     }
     async _send(channel, data, _createElement = []) {
         if (this._state.type === 0 ) {
-            let resolve;
-            const promise = ( new Promise(r => resolve = r));
-            this._state.pendingMessages.push({ channel, data, transferable: _createElement, resolve: resolve });
+            const { promise, resolve } = promiseWithResolvers();
+            this._state.pendingMessages.push({ channel, data, transferable: _createElement, resolve });
             return promise;
         }
         else {

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

@@ -1,5 +1,5 @@
 import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
 import { Action2, MenuId } from '../../../../platform/actions/common/actions.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { Categories } from '../../../../platform/action/common/actionCommonCategories.js';
@@ -110,7 +110,7 @@ class WebViewEditorFindPreviousCommand extends Action2 {
 }
 class ReloadWebviewAction extends Action2 {
     static { this.ID = 'workbench.action.webview.reloadWebviewAction'; }
-    static { this.LABEL = ( localizeWithPath(
+    static { this.LABEL = ( localize2WithPath(
         'vs/workbench/contrib/webviewPanel/browser/webviewCommands',
         'refreshWebviewLabel',
         "Reload Webviews"
@@ -118,7 +118,7 @@ class ReloadWebviewAction extends Action2 {
     constructor() {
         super({
             id: ReloadWebviewAction.ID,
-            title: { value: ReloadWebviewAction.LABEL, original: 'Reload Webviews' },
+            title: ReloadWebviewAction.LABEL,
             category: Categories.Developer,
             menu: [{
                     id: MenuId.CommandPalette

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

@@ -113,7 +113,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
             this.webview.release(this);
         }
         await super.setInput(input, options, context, token);
-        await input.resolve(options);
+        await input.resolve();
         if (token.isCancellationRequested || this._isDisposed) {
             return;
         }

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

@@ -12,7 +12,7 @@ let WebviewEditorInputSerializer = class WebviewEditorInputSerializer {
         return this._webviewWorkbenchService.shouldPersist(input);
     }
     serialize(input) {
-        if (!this._webviewWorkbenchService.shouldPersist(input)) {
+        if (!this.canSerialize(input)) {
             return undefined;
         }
         const data = this.toJson(input);

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

@@ -1,44 +1,41 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Event } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { registerAction2 } from '../../../../platform/actions/common/actions.js';
 import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
 import { EditorPaneDescriptor } from '../../../browser/editor.js';
-import { Extensions } from '../../../common/contributions.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
 import { EditorExtensions } from '../../../common/editor.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { ShowWebViewEditorFindWidgetAction, HideWebViewEditorFindCommand, WebViewEditorFindNextCommand, WebViewEditorFindPreviousCommand, ReloadWebviewAction } from './webviewCommands.js';
 import { WebviewEditor } from './webviewEditor.js';
 import { WebviewInput } from './webviewEditorInput.js';
 import { WebviewEditorInputSerializer } from './webviewEditorInputSerializer.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 (( Registry.as(EditorExtensions.EditorPane))).registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, ( localizeWithPath(
     'vs/workbench/contrib/webviewPanel/browser/webviewPanel.contribution',
     'webview.editor.label',
     "webview editor"
 ))), [( new SyncDescriptor(WebviewInput))]);
 let WebviewPanelContribution = class WebviewPanelContribution extends Disposable {
-    constructor(editorGroupService) {
+    static { this.ID = 'workbench.contrib.webviewPanel'; }
+    constructor(editorService, editorGroupService) {
         super();
         this.editorGroupService = editorGroupService;
-        this.editorGroupService.whenReady.then(() => this.editorGroupService.groups.forEach(group => {
-            this.registerGroupListener(group);
+        this._register(editorService.onWillOpenEditor(e => {
+            const group = editorGroupService.getGroup(e.groupId);
+            if (group) {
+                this.onEditorOpening(e.editor, group);
+            }
         }));
-        this._register(this.editorGroupService.onDidAddGroup(group => this.registerGroupListener(group)));
-    }
-    registerGroupListener(group) {
-        const listener = group.onWillOpenEditor(e => this.onEditorOpening(e.editor, group));
-        Event.once(group.onWillDispose)(() => {
-            listener.dispose();
-        });
     }
     onEditorOpening(editor, group) {
         if (!(editor instanceof WebviewInput) || editor.typeId !== WebviewInput.typeId) {
-            return undefined;
+            return;
         }
         if (group.contains(editor)) {
-            return undefined;
+            return;
         }
         let previousGroup;
         const groups = this.editorGroupService.groups;
@@ -49,16 +46,16 @@ let WebviewPanelContribution = class WebviewPanelContribution extends Disposable
             }
         }
         if (!previousGroup) {
-            return undefined;
+            return;
         }
         previousGroup.closeEditor(editor);
     }
 };
 WebviewPanelContribution = ( __decorate([
-    ( __param(0, IEditorGroupsService))
+    ( __param(0, IEditorService)),
+    ( __param(1, IEditorGroupsService))
 ], WebviewPanelContribution));
-const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
-workbenchContributionsRegistry.registerWorkbenchContribution(WebviewPanelContribution, 1 );
+registerWorkbenchContribution2(WebviewPanelContribution.ID, WebviewPanelContribution, 1 );
 ( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(WebviewEditorInputSerializer.ID, WebviewEditorInputSerializer);
 registerAction2(ShowWebViewEditorFindWidgetAction);
 registerAction2(HideWebViewEditorFindCommand);

package/vscode/src/vs/workbench/contrib/webviewView/browser/webviewViewPane.js

@@ -45,6 +45,7 @@ let WebviewViewPane = class WebviewViewPane extends ViewPane {
         this._webview = this._register(( new MutableDisposable()));
         this._webviewDisposables = this._register(( new DisposableStore()));
         this._activated = false;
+        this.activity = this._register(( new MutableDisposable()));
         this._onDidChangeVisibility = this._register(( new Emitter()));
         this.onDidChangeVisibility = this._onDidChangeVisibility.event;
         this._onDispose = this._register(( new Emitter()));
@@ -174,17 +175,13 @@ let WebviewViewPane = class WebviewViewPane extends ViewPane {
             this.badge?.tooltip === badge?.tooltip) {
             return;
         }
-        if (this.activity) {
-            this.activity.dispose();
-            this.activity = undefined;
-        }
         this.badge = badge;
         if (badge) {
             const activity = {
                 badge: ( new NumberBadge(badge.value, () => badge.tooltip)),
                 priority: 150
             };
-            this.activityService.showViewActivity(this.id, activity);
+            this.activity.value = this.activityService.showViewActivity(this.id, activity);
         }
     }
     async withProgress(task) {

package/vscode/src/vs/workbench/contrib/webviewView/browser/webviewViewService.js

@@ -1,3 +1,4 @@
+import { promiseWithResolvers } from '../../../../base/common/async.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
@@ -34,10 +35,9 @@ class WebviewViewService extends Disposable {
             if (( this._awaitingRevival.has(viewType))) {
                 throw new Error('View already awaiting revival');
             }
-            let resolve;
-            const p = ( new Promise(r => resolve = r));
-            this._awaitingRevival.set(viewType, { webview, resolve: resolve });
-            return p;
+            const { promise, resolve } = promiseWithResolvers();
+            this._awaitingRevival.set(viewType, { webview, resolve });
+            return promise;
         }
         return resolver.resolve(webview, cancellation);
     }

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedExtensionPoint.js

@@ -5,7 +5,7 @@ const titleTranslated = ( localizeWithPath(
     'title',
     "Title"
 ));
-const walkthroughsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const walkthroughsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'walkthroughs',
     jsonSchema: {
         description: ( localizeWithPath(
@@ -371,5 +371,5 @@ const walkthroughsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
+});
 export { walkthroughsExtensionPoint };

package/vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.js

@@ -21,7 +21,7 @@ import { walkthroughsExtensionPoint } from './gettingStartedExtensionPoint.js';
 import { dirname } from '../../../../base/common/path.js';
 import { coalesce, flatten } from '../../../../base/common/arrays.js';
 import { IViewsService } from '../../../services/views/common/viewsService.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { localize2WithPath, localizeWithPath } from '../../../../nls.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
 import { checkGlobFileExists } from '../../../services/extensions/common/workspaceContains.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
@@ -527,16 +527,16 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'resetGettingStartedProgress',
-            category: { original: 'Developer', value: ( localizeWithPath(
+            category: ( localize2WithPath(
                 'vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService',
                 'developer',
                 "Developer"
-            )) },
-            title: { original: 'Reset Welcome Page Walkthrough Progress', value: ( localizeWithPath(
+            )),
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService',
                 'resetWelcomePageWalkthroughProgress',
                 "Reset Welcome Page Walkthrough Progress"
-            )) },
+            )),
             f1: true
         });
     }