@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/contrib/debug/browser/debugSession.js

@@ -803,66 +803,71 @@ let DebugSession = class DebugSession {
                 await this.fetchThreads();
             }
         }));
+        const statusQueue = ( new Queue());
         this.rawListeners.push(this.raw.onDidStop(async (event) => {
-            this.passFocusScheduler.cancel();
-            this.stoppedDetails.push(event.body);
-            await this.fetchThreads(event.body);
-            const focusedThread = this.debugService.getViewModel().focusedThread;
-            const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
-            if (focusedThreadDoesNotExist) {
-                this.debugService.focusStackFrame(undefined, undefined);
-            }
-            const thread = typeof event.body.threadId === 'number' ? this.getThread(event.body.threadId) : undefined;
-            if (thread) {
-                const promises = this.model.refreshTopOfCallstack(thread);
-                const focus = async () => {
-                    if (focusedThreadDoesNotExist || (!event.body.preserveFocusHint && thread.getCallStack().length)) {
-                        const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                        if (!focusedStackFrame || focusedStackFrame.thread.session === this) {
-                            const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
-                            await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
-                        }
-                        if (thread.stoppedDetails) {
-                            if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
-                                await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
+            statusQueue.queue(async () => {
+                this.passFocusScheduler.cancel();
+                this.stoppedDetails.push(event.body);
+                await this.fetchThreads(event.body);
+                const focusedThread = this.debugService.getViewModel().focusedThread;
+                const focusedThreadDoesNotExist = focusedThread !== undefined && focusedThread.session === this && !( this.threads.has(focusedThread.threadId));
+                if (focusedThreadDoesNotExist) {
+                    this.debugService.focusStackFrame(undefined, undefined);
+                }
+                const thread = typeof event.body.threadId === 'number' ? this.getThread(event.body.threadId) : undefined;
+                if (thread) {
+                    const promises = this.model.refreshTopOfCallstack(thread);
+                    const focus = async () => {
+                        if (focusedThreadDoesNotExist || (!event.body.preserveFocusHint && thread.getCallStack().length)) {
+                            const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                            if (!focusedStackFrame || focusedStackFrame.thread.session === this) {
+                                const preserveFocus = !this.configurationService.getValue('debug').focusEditorOnBreak;
+                                await this.debugService.focusStackFrame(undefined, thread, undefined, { preserveFocus });
                             }
-                            if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
-                                await this.hostService.focus({ force: true  });
+                            if (thread.stoppedDetails) {
+                                if (thread.stoppedDetails.reason === 'breakpoint' && this.configurationService.getValue('debug').openDebug === 'openOnDebugBreak' && !this.suppressDebugView) {
+                                    await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 );
+                                }
+                                if (this.configurationService.getValue('debug').focusWindowOnBreak && !this.workbenchEnvironmentService.extensionTestsLocationURI) {
+                                    await this.hostService.focus({ force: true  });
+                                }
                             }
                         }
-                    }
-                };
-                await promises.topCallStack;
-                focus();
-                await promises.wholeCallStack;
-                const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
+                    };
+                    await promises.topCallStack;
                     focus();
+                    await promises.wholeCallStack;
+                    const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
+                    if (!focusedStackFrame || !focusedStackFrame.source || focusedStackFrame.source.presentationHint === 'deemphasize' || focusedStackFrame.presentationHint === 'deemphasize') {
+                        focus();
+                    }
                 }
-            }
-            this._onDidChangeState.fire();
+                this._onDidChangeState.fire();
+            });
         }));
         this.rawListeners.push(this.raw.onDidThread(event => {
-            if (event.body.reason === 'started') {
-                if (!this.fetchThreadsScheduler) {
-                    this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
-                        this.fetchThreads();
-                    }, 100));
-                    this.rawListeners.push(this.fetchThreadsScheduler);
-                }
-                if (!this.fetchThreadsScheduler.isScheduled()) {
-                    this.fetchThreadsScheduler.schedule();
+            statusQueue.queue(async () => {
+                if (event.body.reason === 'started') {
+                    if (!this.fetchThreadsScheduler) {
+                        this.fetchThreadsScheduler = ( new RunOnceScheduler(() => {
+                            this.fetchThreads();
+                        }, 100));
+                        this.rawListeners.push(this.fetchThreadsScheduler);
+                    }
+                    if (!this.fetchThreadsScheduler.isScheduled()) {
+                        this.fetchThreadsScheduler.schedule();
+                    }
                 }
-            }
-            else if (event.body.reason === 'exited') {
-                this.model.clearThreads(this.getId(), true, event.body.threadId);
-                const viewModel = this.debugService.getViewModel();
-                const focusedThread = viewModel.focusedThread;
-                this.passFocusScheduler.cancel();
-                if (focusedThread && event.body.threadId === focusedThread.threadId) {
-                    this.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, { explicit: false });
+                else if (event.body.reason === 'exited') {
+                    this.model.clearThreads(this.getId(), true, event.body.threadId);
+                    const viewModel = this.debugService.getViewModel();
+                    const focusedThread = viewModel.focusedThread;
+                    this.passFocusScheduler.cancel();
+                    if (focusedThread && event.body.threadId === focusedThread.threadId) {
+                        this.debugService.focusStackFrame(undefined, undefined, viewModel.focusedSession, { explicit: false });
+                    }
                 }
-            }
+            });
         }));
         this.rawListeners.push(this.raw.onDidTerminateDebugee(async (event) => {
             aria.status(( localize('debuggingStopped', "Debugging stopped.")));
@@ -874,21 +879,23 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.push(this.raw.onDidContinued(event => {
-            const threadId = event.body.allThreadsContinued !== false ? undefined : event.body.threadId;
-            if (typeof threadId === 'number') {
-                this.stoppedDetails = this.stoppedDetails.filter(sd => sd.threadId !== threadId);
-                const tokens = this.cancellationMap.get(threadId);
-                this.cancellationMap.delete(threadId);
-                tokens?.forEach(t => t.cancel());
-            }
-            else {
-                this.stoppedDetails = [];
-                this.cancelAllRequests();
-            }
-            this.lastContinuedThreadId = threadId;
-            this.passFocusScheduler.schedule();
-            this.model.clearThreads(this.getId(), false, threadId);
-            this._onDidChangeState.fire();
+            statusQueue.queue(async () => {
+                const threadId = event.body.allThreadsContinued !== false ? undefined : event.body.threadId;
+                if (typeof threadId === 'number') {
+                    this.stoppedDetails = this.stoppedDetails.filter(sd => sd.threadId !== threadId);
+                    const tokens = this.cancellationMap.get(threadId);
+                    this.cancellationMap.delete(threadId);
+                    tokens?.forEach(t => t.cancel());
+                }
+                else {
+                    this.stoppedDetails = [];
+                    this.cancelAllRequests();
+                }
+                this.lastContinuedThreadId = threadId;
+                this.passFocusScheduler.schedule();
+                this.model.clearThreads(this.getId(), false, threadId);
+                this._onDidChangeState.fire();
+            });
         }));
         const outputQueue = ( new Queue());
         this.rawListeners.push(this.raw.onDidOutput(async (event) => {

package/dist/vscode/vs/workbench/contrib/debug/browser/debugViewlet.js

@@ -0,0 +1,166 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import "../../../../../../assets/debugViewlet.css";
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ViewsSubMenu, ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { IViewsService, IViewDescriptorService } from '../../../common/views.js';
+import { StartDebugActionViewItem, FocusSessionActionViewItem } from './debugActionViewItems.js';
+import { DEBUG_START_COMMAND_ID, FOCUS_SESSION_ID, STOP_ID, DISCONNECT_ID } from './debugCommands.js';
+import { createDisconnectMenuItemAction } from './debugToolBar.js';
+import { WelcomeView } from './welcomeView.js';
+import { REPL_VIEW_ID, VIEWLET_ID, CONTEXT_DEBUG_UX_KEY, BREAKPOINTS_VIEW_ID, IDebugService } from '../common/debug.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+let DebugViewPaneContainer = class DebugViewPaneContainer extends ViewPaneContainer {
+    constructor(layoutService, telemetryService, progressService, debugService, instantiationService, contextService, storageService, themeService, contextMenuService, extensionService, configurationService, contextViewService, contextKeyService, viewDescriptorService) {
+        super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
+        this.progressService = progressService;
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+        this.contextKeyService = contextKeyService;
+        this.paneListeners = ( new Map());
+        this.stopActionViewItemDisposables = this._register(( new DisposableStore()));
+        this._register(this.debugService.onDidChangeState(state => this.onDebugServiceStateChange(state)));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(( new Set([CONTEXT_DEBUG_UX_KEY])))) {
+                this.updateTitleArea();
+            }
+        }));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateTitleArea()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration('debug.toolBarLocation')) {
+                this.updateTitleArea();
+            }
+        }));
+    }
+    create(parent) {
+        super.create(parent);
+        parent.classList.add('debug-viewlet');
+    }
+    focus() {
+        super.focus();
+        if (this.startDebugActionViewItem) {
+            this.startDebugActionViewItem.focus();
+        }
+        else {
+            this.focusView(WelcomeView.ID);
+        }
+    }
+    getActionViewItem(action) {
+        if (action.id === DEBUG_START_COMMAND_ID) {
+            this.startDebugActionViewItem = this.instantiationService.createInstance(StartDebugActionViewItem, null, action);
+            return this.startDebugActionViewItem;
+        }
+        if (action.id === FOCUS_SESSION_ID) {
+            return ( new FocusSessionActionViewItem(
+                action,
+                undefined,
+                this.debugService,
+                this.contextViewService,
+                this.configurationService
+            ));
+        }
+        if (action.id === STOP_ID || action.id === DISCONNECT_ID) {
+            this.stopActionViewItemDisposables.clear();
+            const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, this.stopActionViewItemDisposables, accessor));
+            if (item) {
+                return item;
+            }
+        }
+        return createActionViewItem(this.instantiationService, action);
+    }
+    focusView(id) {
+        const view = this.getView(id);
+        if (view) {
+            view.focus();
+        }
+    }
+    onDebugServiceStateChange(state) {
+        if (this.progressResolve) {
+            this.progressResolve();
+            this.progressResolve = undefined;
+        }
+        if (state === 1 ) {
+            this.progressService.withProgress({ location: VIEWLET_ID, }, _progress => {
+                return ( new Promise(resolve => this.progressResolve = resolve));
+            });
+        }
+    }
+    addPanes(panes) {
+        super.addPanes(panes);
+        for (const { pane: pane } of panes) {
+            if (pane.id === BREAKPOINTS_VIEW_ID) {
+                this.breakpointView = pane;
+                this.updateBreakpointsMaxSize();
+            }
+            else {
+                this.paneListeners.set(pane.id, pane.onDidChange(() => this.updateBreakpointsMaxSize()));
+            }
+        }
+    }
+    removePanes(panes) {
+        super.removePanes(panes);
+        for (const pane of panes) {
+            dispose(this.paneListeners.get(pane.id));
+            this.paneListeners.delete(pane.id);
+        }
+    }
+    updateBreakpointsMaxSize() {
+        if (this.breakpointView) {
+            const allOtherCollapsed = this.panes.every(view => !view.isExpanded() || view === this.breakpointView);
+            this.breakpointView.maximumBodySize = allOtherCollapsed ? Number.POSITIVE_INFINITY : this.breakpointView.minimumBodySize;
+        }
+    }
+};
+DebugViewPaneContainer = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IProgressService)),
+    ( __param(3, IDebugService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IExtensionService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IContextViewService)),
+    ( __param(12, IContextKeyService)),
+    ( __param(13, IViewDescriptorService))
+], DebugViewPaneContainer));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'debug.toggleReplIgnoreFocus',
+            title: ( nls.localize('debugPanel', "Debug Console")),
+            toggled: ( ContextKeyExpr.has(`view.${REPL_VIEW_ID}.visible`)),
+            menu: [{
+                    id: ViewsSubMenu,
+                    group: '3_toggleRepl',
+                    order: 30,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID))))
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        if (viewsService.isViewVisible(REPL_VIEW_ID)) {
+            viewsService.closeView(REPL_VIEW_ID);
+        }
+        else {
+            await viewsService.openView(REPL_VIEW_ID);
+        }
+    }
+});
+export { DebugViewPaneContainer };

package/dist/vscode/vs/workbench/contrib/debug/browser/linkDetector.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
@@ -93,8 +93,8 @@ let LinkDetector = class LinkDetector {
         this.decorateLink(link, uri, fulltext, async () => {
             if (uri.scheme === Schemas.file) {
                 const fsPath = uri.fsPath;
-                const path = await this.pathService.path;
-                const fileUrl = paths.normalize(((path.sep === paths.posix.sep) && platform.isWindows) ? fsPath.replace(/\\/g, paths.posix.sep) : fsPath);
+                const path$1 = await this.pathService.path;
+                const fileUrl = path.normalize(((path$1.sep === path.posix.sep) && platform.isWindows) ? fsPath.replace(/\\/g, path.posix.sep) : fsPath);
                 const fileUri = ( URI.parse(fileUrl));
                 const exists = await this.fileService.exists(fileUri);
                 if (!exists) {
@@ -113,29 +113,29 @@ let LinkDetector = class LinkDetector {
         });
         return link;
     }
-    createPathLink(fulltext, text, path, lineNumber, columnNumber, workspaceFolder) {
-        if (path[0] === '/' && path[1] === '/') {
+    createPathLink(fulltext, text, path$1, lineNumber, columnNumber, workspaceFolder) {
+        if (path$1[0] === '/' && path$1[1] === '/') {
             return document.createTextNode(text);
         }
         const options = { selection: { startLineNumber: lineNumber, startColumn: columnNumber } };
-        if (path[0] === '.') {
+        if (path$1[0] === '.') {
             if (!workspaceFolder) {
                 return document.createTextNode(text);
             }
-            const uri = workspaceFolder.toResource(path);
+            const uri = workspaceFolder.toResource(path$1);
             const link = this.createLink(text);
             this.decorateLink(link, uri, fulltext, (preserveFocus) => this.editorService.openEditor({ resource: uri, options: { ...options, preserveFocus } }));
             return link;
         }
-        if (path[0] === '~') {
+        if (path$1[0] === '~') {
             const userHome = this.pathService.resolvedUserHome;
             if (userHome) {
-                path = paths.join(userHome.fsPath, path.substring(1));
+                path$1 = path.join(userHome.fsPath, path$1.substring(1));
             }
         }
         const link = this.createLink(text);
         link.tabIndex = 0;
-        const uri = URI.file(paths.normalize(path));
+        const uri = URI.file(path.normalize(path$1));
         this.fileService.stat(uri).then(stat => {
             if (stat.isDirectory) {
                 return;