@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

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

@@ -0,0 +1,954 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { commonSuffixLength } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createAndFillInContextMenuActions, MenuEntryActionViewItem, SubmenuEntryActionViewItem, createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { registerAction2, MenuId, MenuItemAction, SubmenuItemAction, MenuRegistry, IMenuService } 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 } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { WorkbenchCompressibleAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { asCssVariable, textLinkForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ViewAction, ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { renderViewTree } from './baseDebugView.js';
+import { STOP_ID, DISCONNECT_ID, PAUSE_LABEL, PAUSE_ID, CONTINUE_LABEL, CONTINUE_ID, STEP_OVER_LABEL, STEP_OVER_ID, STEP_INTO_LABEL, STEP_INTO_ID, STEP_OUT_LABEL, STEP_OUT_ID, RESTART_LABEL, RESTART_SESSION_ID, STOP_LABEL, DISCONNECT_LABEL } from './debugCommands.js';
+import { callstackViewSession, debugRestartFrame, debugPause, debugContinue, debugStepOver, debugStepInto, debugStepOut, debugRestart, debugStop, debugDisconnect } from './debugIcons.js';
+import { createDisconnectMenuItemAction } from './debugToolBar.js';
+import { CALLSTACK_VIEW_ID, CONTEXT_DEBUG_STATE, getStateLabel, CONTEXT_CALLSTACK_ITEM_TYPE, CONTEXT_CALLSTACK_SESSION_IS_ATTACH, CONTEXT_CALLSTACK_ITEM_STOPPED, CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD, IDebugService, CONTEXT_STACK_FRAME_SUPPORTS_RESTART } from '../common/debug.js';
+import { Thread, StackFrame, ThreadAndSessionIds } from '../common/debugModel.js';
+import { isSessionAttach } from '../common/debugUtils.js';
+const $ = dom.$;
+function assignSessionContext(element, context) {
+    context.sessionId = element.getId();
+    return context;
+}
+function assignThreadContext(element, context) {
+    context.threadId = element.getId();
+    assignSessionContext(element.session, context);
+    return context;
+}
+function assignStackFrameContext(element, context) {
+    context.frameId = element.getId();
+    context.frameName = element.name;
+    context.frameLocation = { range: element.range, source: element.source.raw };
+    assignThreadContext(element.thread, context);
+    return context;
+}
+function getContext(element) {
+    if (element instanceof StackFrame) {
+        return assignStackFrameContext(element, {});
+    }
+    else if (element instanceof Thread) {
+        return assignThreadContext(element, {});
+    }
+    else if (isDebugSession(element)) {
+        return assignSessionContext(element, {});
+    }
+    else {
+        return undefined;
+    }
+}
+function getContextForContributedActions(element) {
+    if (element instanceof StackFrame) {
+        if (element.source.inMemory) {
+            return element.source.raw.path || element.source.reference || element.source.name;
+        }
+        return ( element.source.uri.toString());
+    }
+    if (element instanceof Thread) {
+        return element.threadId;
+    }
+    if (isDebugSession(element)) {
+        return element.getId();
+    }
+    return '';
+}
+function getSpecificSourceName(stackFrame) {
+    let callStack = stackFrame.thread.getStaleCallStack();
+    callStack = callStack.length > 0 ? callStack : stackFrame.thread.getCallStack();
+    const otherSources = ( callStack.map(sf => sf.source)).filter(s => s !== stackFrame.source);
+    let suffixLength = 0;
+    otherSources.forEach(s => {
+        if (s.name === stackFrame.source.name) {
+            suffixLength = Math.max(suffixLength, commonSuffixLength(stackFrame.source.uri.path, s.uri.path));
+        }
+    });
+    if (suffixLength === 0) {
+        return stackFrame.source.name;
+    }
+    const from = Math.max(0, stackFrame.source.uri.path.lastIndexOf(posix.sep, stackFrame.source.uri.path.length - suffixLength - 1));
+    return (from > 0 ? '...' : '') + stackFrame.source.uri.path.substring(from);
+}
+async function expandTo(session, tree) {
+    if (session.parentSession) {
+        await expandTo(session.parentSession, tree);
+    }
+    await tree.expand(session);
+}
+let CallStackView = class CallStackView extends ViewPane {
+    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, telemetryService, menuService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.options = options;
+        this.debugService = debugService;
+        this.menuService = menuService;
+        this.needsRefresh = false;
+        this.ignoreSelectionChangedEvent = false;
+        this.ignoreFocusStackFrameEvent = false;
+        this.autoExpandedSessions = ( new Set());
+        this.selectionNeedsUpdate = false;
+        this.onCallStackChangeScheduler = this._register(( new RunOnceScheduler(async () => {
+            const sessions = this.debugService.getModel().getSessions();
+            if (sessions.length === 0) {
+                this.autoExpandedSessions.clear();
+            }
+            const thread = sessions.length === 1 && sessions[0].getAllThreads().length === 1 ? sessions[0].getAllThreads()[0] : undefined;
+            const stoppedDetails = sessions.length === 1 ? sessions[0].getStoppedDetails() : undefined;
+            if (stoppedDetails && (thread || typeof stoppedDetails.threadId !== 'number')) {
+                this.stateMessageLabel.textContent = stoppedDescription(stoppedDetails);
+                this.stateMessageLabel.title = stoppedText(stoppedDetails);
+                this.stateMessageLabel.classList.toggle('exception', stoppedDetails.reason === 'exception');
+                this.stateMessage.hidden = false;
+            }
+            else if (sessions.length === 1 && sessions[0].state === 3 ) {
+                this.stateMessageLabel.textContent = ( localize({ key: 'running', comment: ['indicates state'] }, "Running"));
+                this.stateMessageLabel.title = sessions[0].getLabel();
+                this.stateMessageLabel.classList.remove('exception');
+                this.stateMessage.hidden = false;
+            }
+            else {
+                this.stateMessage.hidden = true;
+            }
+            this.updateActions();
+            this.needsRefresh = false;
+            this.dataSource.deemphasizedStackFramesToShow = [];
+            await this.tree.updateChildren();
+            try {
+                const toExpand = ( new Set());
+                sessions.forEach(s => {
+                    if (s.parentSession && !( this.autoExpandedSessions.has(s.parentSession))) {
+                        toExpand.add(s.parentSession);
+                    }
+                });
+                for (const session of toExpand) {
+                    await expandTo(session, this.tree);
+                    this.autoExpandedSessions.add(session);
+                }
+            }
+            catch (e) {
+            }
+            if (this.selectionNeedsUpdate) {
+                this.selectionNeedsUpdate = false;
+                await this.updateTreeSelection();
+            }
+        }, 50)));
+    }
+    renderHeaderTitle(container) {
+        super.renderHeaderTitle(container, this.options.title);
+        this.stateMessage = dom.append(container, $('span.call-stack-state-message'));
+        this.stateMessage.hidden = true;
+        this.stateMessageLabel = dom.append(this.stateMessage, $('span.label'));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.element.classList.add('debug-pane');
+        container.classList.add('debug-call-stack');
+        const treeContainer = renderViewTree(container);
+        this.dataSource = ( new CallStackDataSource(this.debugService));
+        this.tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'CallStackView', treeContainer, ( new CallStackDelegate()), ( new CallStackCompressionDelegate(this.debugService)), [
+            this.instantiationService.createInstance(SessionsRenderer),
+            this.instantiationService.createInstance(ThreadsRenderer),
+            this.instantiationService.createInstance(StackFramesRenderer),
+            ( new ErrorsRenderer()),
+            ( new LoadMoreRenderer()),
+            ( new ShowMoreRenderer())
+        ], this.dataSource, {
+            accessibilityProvider: ( new CallStackAccessibilityProvider()),
+            compressionEnabled: true,
+            autoExpandSingleChildren: true,
+            identityProvider: {
+                getId: (element) => {
+                    if (typeof element === 'string') {
+                        return element;
+                    }
+                    if (element instanceof Array) {
+                        return `showMore ${element[0].getId()}`;
+                    }
+                    return element.getId();
+                }
+            },
+            keyboardNavigationLabelProvider: {
+                getKeyboardNavigationLabel: (e) => {
+                    if (isDebugSession(e)) {
+                        return e.getLabel();
+                    }
+                    if (e instanceof Thread) {
+                        return `${e.name} ${e.stateLabel}`;
+                    }
+                    if (e instanceof StackFrame || typeof e === 'string') {
+                        return e;
+                    }
+                    if (e instanceof ThreadAndSessionIds) {
+                        return LoadMoreRenderer.LABEL;
+                    }
+                    return ( localize('showMoreStackFrames2', "Show More Stack Frames"));
+                },
+                getCompressedNodeKeyboardNavigationLabel: (e) => {
+                    const firstItem = e[0];
+                    if (isDebugSession(firstItem)) {
+                        return firstItem.getLabel();
+                    }
+                    return '';
+                }
+            },
+            expandOnlyOnTwistieClick: true,
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        this.tree.setInput(this.debugService.getModel());
+        this._register(this.tree.onDidOpen(async (e) => {
+            if (this.ignoreSelectionChangedEvent) {
+                return;
+            }
+            const focusStackFrame = (stackFrame, thread, session, options = {}) => {
+                this.ignoreFocusStackFrameEvent = true;
+                try {
+                    this.debugService.focusStackFrame(stackFrame, thread, session, { ...options, ...{ explicit: true } });
+                }
+                finally {
+                    this.ignoreFocusStackFrameEvent = false;
+                }
+            };
+            const element = e.element;
+            if (element instanceof StackFrame) {
+                const opts = {
+                    preserveFocus: e.editorOptions.preserveFocus,
+                    sideBySide: e.sideBySide,
+                    pinned: e.editorOptions.pinned
+                };
+                focusStackFrame(element, element.thread, element.thread.session, opts);
+            }
+            if (element instanceof Thread) {
+                focusStackFrame(undefined, element, element.session);
+            }
+            if (isDebugSession(element)) {
+                focusStackFrame(undefined, undefined, element);
+            }
+            if (element instanceof ThreadAndSessionIds) {
+                const session = this.debugService.getModel().getSession(element.sessionId);
+                const thread = session && session.getThread(element.threadId);
+                if (thread) {
+                    const totalFrames = thread.stoppedDetails?.totalFrames;
+                    const remainingFramesCount = typeof totalFrames === 'number' ? (totalFrames - thread.getCallStack().length) : undefined;
+                    await thread.fetchCallStack(remainingFramesCount);
+                    await this.tree.updateChildren();
+                }
+            }
+            if (element instanceof Array) {
+                this.dataSource.deemphasizedStackFramesToShow.push(...element);
+                this.tree.updateChildren();
+            }
+        }));
+        this._register(this.debugService.getModel().onDidChangeCallStack(() => {
+            if (!this.isBodyVisible()) {
+                this.needsRefresh = true;
+                return;
+            }
+            if (!this.onCallStackChangeScheduler.isScheduled()) {
+                this.onCallStackChangeScheduler.schedule();
+            }
+        }));
+        const onFocusChange = Event.any(this.debugService.getViewModel().onDidFocusStackFrame, this.debugService.getViewModel().onDidFocusSession);
+        this._register(onFocusChange(async () => {
+            if (this.ignoreFocusStackFrameEvent) {
+                return;
+            }
+            if (!this.isBodyVisible()) {
+                this.needsRefresh = true;
+                return;
+            }
+            if (this.onCallStackChangeScheduler.isScheduled()) {
+                this.selectionNeedsUpdate = true;
+                return;
+            }
+            await this.updateTreeSelection();
+        }));
+        this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
+        if (this.debugService.state === 2 ) {
+            this.onCallStackChangeScheduler.schedule(0);
+        }
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible && this.needsRefresh) {
+                this.onCallStackChangeScheduler.schedule();
+            }
+        }));
+        this._register(this.debugService.onDidNewSession(s => {
+            const sessionListeners = [];
+            sessionListeners.push(s.onDidChangeName(() => {
+                if (this.tree.hasNode(s)) {
+                    this.tree.rerender(s);
+                }
+            }));
+            sessionListeners.push(s.onDidEndAdapter(() => dispose(sessionListeners)));
+            if (s.parentSession) {
+                this.autoExpandedSessions.delete(s.parentSession);
+            }
+        }));
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.tree.layout(height, width);
+    }
+    focus() {
+        this.tree.domFocus();
+    }
+    collapseAll() {
+        this.tree.collapseAll();
+    }
+    async updateTreeSelection() {
+        if (!this.tree || !this.tree.getInput()) {
+            return;
+        }
+        const updateSelectionAndReveal = (element) => {
+            this.ignoreSelectionChangedEvent = true;
+            try {
+                this.tree.setSelection([element]);
+                if (this.tree.getRelativeTop(element) === null) {
+                    this.tree.reveal(element, 0.5);
+                }
+                else {
+                    this.tree.reveal(element);
+                }
+            }
+            catch (e) { }
+            finally {
+                this.ignoreSelectionChangedEvent = false;
+            }
+        };
+        const thread = this.debugService.getViewModel().focusedThread;
+        const session = this.debugService.getViewModel().focusedSession;
+        const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+        if (!thread) {
+            if (!session) {
+                this.tree.setSelection([]);
+            }
+            else {
+                updateSelectionAndReveal(session);
+            }
+        }
+        else {
+            try {
+                await expandTo(thread.session, this.tree);
+            }
+            catch (e) { }
+            try {
+                await this.tree.expand(thread);
+            }
+            catch (e) { }
+            const toReveal = stackFrame || session;
+            if (toReveal) {
+                updateSelectionAndReveal(toReveal);
+            }
+        }
+    }
+    onContextMenu(e) {
+        const element = e.element;
+        let overlay = [];
+        if (isDebugSession(element)) {
+            overlay = getSessionContextOverlay(element);
+        }
+        else if (element instanceof Thread) {
+            overlay = getThreadContextOverlay(element);
+        }
+        else if (element instanceof StackFrame) {
+            overlay = getStackFrameContextOverlay(element);
+        }
+        const primary = [];
+        const secondary = [];
+        const result = { primary, secondary };
+        const contextKeyService = this.contextKeyService.createOverlay(overlay);
+        const menu = this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService);
+        createAndFillInContextMenuActions(menu, { arg: getContextForContributedActions(element), shouldForwardArgs: true }, result, 'inline');
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => result.secondary,
+            getActionsContext: () => getContext(element)
+        });
+    }
+};
+CallStackView = ( __decorate([
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IMenuService))
+], CallStackView));
+function getSessionContextOverlay(session) {
+    return [
+        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'session'],
+        [CONTEXT_CALLSTACK_SESSION_IS_ATTACH.key, isSessionAttach(session)],
+        [CONTEXT_CALLSTACK_ITEM_STOPPED.key, session.state === 2 ],
+        [CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD.key, session.getAllThreads().length === 1],
+    ];
+}
+let SessionsRenderer = class SessionsRenderer {
+    constructor(instantiationService, contextKeyService, menuService) {
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+    }
+    get templateId() {
+        return SessionsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const session = dom.append(container, $('.session'));
+        dom.append(session, $(ThemeIcon.asCSSSelector(callstackViewSession)));
+        const name = dom.append(session, $('.name'));
+        const stateLabel = dom.append(session, $('span.state.label.monaco-count-badge.long'));
+        const label = ( new HighlightedLabel(name));
+        const templateDisposable = ( new DisposableStore());
+        const stopActionViewItemDisposables = templateDisposable.add(( new DisposableStore()));
+        const actionBar = templateDisposable.add(( new ActionBar(session, {
+            actionViewItemProvider: action => {
+                if ((action.id === STOP_ID || action.id === DISCONNECT_ID) && action instanceof MenuItemAction) {
+                    stopActionViewItemDisposables.clear();
+                    const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, stopActionViewItemDisposables, accessor));
+                    if (item) {
+                        return item;
+                    }
+                }
+                if (action instanceof MenuItemAction) {
+                    return this.instantiationService.createInstance(MenuEntryActionViewItem, action, undefined);
+                }
+                else if (action instanceof SubmenuItemAction) {
+                    return this.instantiationService.createInstance(SubmenuEntryActionViewItem, action, undefined);
+                }
+                return undefined;
+            }
+        })));
+        const elementDisposable = templateDisposable.add(( new DisposableStore()));
+        return { session, name, stateLabel, label, actionBar, elementDisposable, templateDisposable };
+    }
+    renderElement(element, _, data) {
+        this.doRenderElement(element.element, createMatches(element.filterData), data);
+    }
+    renderCompressedElements(node, _index, templateData) {
+        const lastElement = node.element.elements[node.element.elements.length - 1];
+        const matches = createMatches(node.filterData);
+        this.doRenderElement(lastElement, matches, templateData);
+    }
+    doRenderElement(session, matches, data) {
+        data.session.title = ( localize({ key: 'session', comment: ['Session is a noun'] }, "Session"));
+        data.label.set(session.getLabel(), matches);
+        const stoppedDetails = session.getStoppedDetails();
+        const thread = session.getAllThreads().find(t => t.stopped);
+        const contextKeyService = this.contextKeyService.createOverlay(getSessionContextOverlay(session));
+        const menu = data.elementDisposable.add(this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService));
+        const setupActionBar = () => {
+            data.actionBar.clear();
+            const primary = [];
+            const secondary = [];
+            const result = { primary, secondary };
+            createAndFillInActionBarActions(menu, { arg: getContextForContributedActions(session), shouldForwardArgs: true }, result, 'inline');
+            data.actionBar.push(primary, { icon: true, label: false });
+            data.actionBar.context = getContext(session);
+        };
+        data.elementDisposable.add(menu.onDidChange(() => setupActionBar()));
+        setupActionBar();
+        data.stateLabel.style.display = '';
+        if (stoppedDetails) {
+            data.stateLabel.textContent = stoppedDescription(stoppedDetails);
+            data.session.title = `${session.getLabel()}: ${stoppedText(stoppedDetails)}`;
+            data.stateLabel.classList.toggle('exception', stoppedDetails.reason === 'exception');
+        }
+        else if (thread && thread.stoppedDetails) {
+            data.stateLabel.textContent = stoppedDescription(thread.stoppedDetails);
+            data.session.title = `${session.getLabel()}: ${stoppedText(thread.stoppedDetails)}`;
+            data.stateLabel.classList.toggle('exception', thread.stoppedDetails.reason === 'exception');
+        }
+        else {
+            data.stateLabel.textContent = ( localize({ key: 'running', comment: ['indicates state'] }, "Running"));
+            data.stateLabel.classList.remove('exception');
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposable.dispose();
+    }
+    disposeElement(_element, _, templateData) {
+        templateData.elementDisposable.clear();
+    }
+    disposeCompressedElements(node, index, templateData, height) {
+        templateData.elementDisposable.clear();
+    }
+};
+SessionsRenderer.ID = 'session';
+SessionsRenderer = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IMenuService))
+], SessionsRenderer));
+function getThreadContextOverlay(thread) {
+    return [
+        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'thread'],
+        [CONTEXT_CALLSTACK_ITEM_STOPPED.key, thread.stopped]
+    ];
+}
+let ThreadsRenderer = class ThreadsRenderer {
+    constructor(contextKeyService, menuService) {
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+    }
+    get templateId() {
+        return ThreadsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const thread = dom.append(container, $('.thread'));
+        const name = dom.append(thread, $('.name'));
+        const stateLabel = dom.append(thread, $('span.state.label.monaco-count-badge.long'));
+        const label = ( new HighlightedLabel(name));
+        const templateDisposable = ( new DisposableStore());
+        const actionBar = templateDisposable.add(( new ActionBar(thread)));
+        const elementDisposable = templateDisposable.add(( new DisposableStore()));
+        return { thread, name, stateLabel, label, actionBar, elementDisposable, templateDisposable };
+    }
+    renderElement(element, _index, data) {
+        const thread = element.element;
+        data.thread.title = thread.name;
+        data.label.set(thread.name, createMatches(element.filterData));
+        data.stateLabel.textContent = thread.stateLabel;
+        data.stateLabel.classList.toggle('exception', thread.stoppedDetails?.reason === 'exception');
+        const contextKeyService = this.contextKeyService.createOverlay(getThreadContextOverlay(thread));
+        const menu = data.elementDisposable.add(this.menuService.createMenu(MenuId.DebugCallStackContext, contextKeyService));
+        const setupActionBar = () => {
+            data.actionBar.clear();
+            const primary = [];
+            const secondary = [];
+            const result = { primary, secondary };
+            createAndFillInActionBarActions(menu, { arg: getContextForContributedActions(thread), shouldForwardArgs: true }, result, 'inline');
+            data.actionBar.push(primary, { icon: true, label: false });
+            data.actionBar.context = getContext(thread);
+        };
+        data.elementDisposable.add(menu.onDidChange(() => setupActionBar()));
+        setupActionBar();
+    }
+    renderCompressedElements(_node, _index, _templateData, _height) {
+        throw new Error('Method not implemented.');
+    }
+    disposeElement(_element, _index, templateData) {
+        templateData.elementDisposable.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.templateDisposable.dispose();
+    }
+};
+ThreadsRenderer.ID = 'thread';
+ThreadsRenderer = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IMenuService))
+], ThreadsRenderer));
+function getStackFrameContextOverlay(stackFrame) {
+    return [
+        [CONTEXT_CALLSTACK_ITEM_TYPE.key, 'stackFrame'],
+        [CONTEXT_STACK_FRAME_SUPPORTS_RESTART.key, stackFrame.canRestart]
+    ];
+}
+let StackFramesRenderer = class StackFramesRenderer {
+    constructor(labelService, notificationService) {
+        this.labelService = labelService;
+        this.notificationService = notificationService;
+    }
+    get templateId() {
+        return StackFramesRenderer.ID;
+    }
+    renderTemplate(container) {
+        const stackFrame = dom.append(container, $('.stack-frame'));
+        const labelDiv = dom.append(stackFrame, $('span.label.expression'));
+        const file = dom.append(stackFrame, $('.file'));
+        const fileName = dom.append(file, $('span.file-name'));
+        const wrapper = dom.append(file, $('span.line-number-wrapper'));
+        const lineNumber = dom.append(wrapper, $('span.line-number.monaco-count-badge'));
+        const label = ( new HighlightedLabel(labelDiv));
+        const templateDisposable = ( new DisposableStore());
+        const actionBar = templateDisposable.add(( new ActionBar(stackFrame)));
+        return { file, fileName, label, lineNumber, stackFrame, actionBar, templateDisposable };
+    }
+    renderElement(element, index, data) {
+        const stackFrame = element.element;
+        data.stackFrame.classList.toggle('disabled', !stackFrame.source || !stackFrame.source.available || isDeemphasized(stackFrame));
+        data.stackFrame.classList.toggle('label', stackFrame.presentationHint === 'label');
+        data.stackFrame.classList.toggle('subtle', stackFrame.presentationHint === 'subtle');
+        const hasActions = !!stackFrame.thread.session.capabilities.supportsRestartFrame && stackFrame.presentationHint !== 'label' && stackFrame.presentationHint !== 'subtle' && stackFrame.canRestart;
+        data.stackFrame.classList.toggle('has-actions', hasActions);
+        data.file.title = stackFrame.source.inMemory ? stackFrame.source.uri.path : this.labelService.getUriLabel(stackFrame.source.uri);
+        if (stackFrame.source.raw.origin) {
+            data.file.title += `\n${stackFrame.source.raw.origin}`;
+        }
+        data.label.set(stackFrame.name, createMatches(element.filterData), stackFrame.name);
+        data.fileName.textContent = getSpecificSourceName(stackFrame);
+        if (stackFrame.range.startLineNumber !== undefined) {
+            data.lineNumber.textContent = `${stackFrame.range.startLineNumber}`;
+            if (stackFrame.range.startColumn) {
+                data.lineNumber.textContent += `:${stackFrame.range.startColumn}`;
+            }
+            data.lineNumber.classList.remove('unavailable');
+        }
+        else {
+            data.lineNumber.classList.add('unavailable');
+        }
+        data.actionBar.clear();
+        if (hasActions) {
+            const action = ( new Action('debug.callStack.restartFrame', ( localize('restartFrame', "Restart Frame")), ThemeIcon.asClassName(debugRestartFrame), true, async () => {
+                try {
+                    await stackFrame.restart();
+                }
+                catch (e) {
+                    this.notificationService.error(e);
+                }
+            }));
+            data.actionBar.push(action, { icon: true, label: false });
+        }
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Method not implemented.');
+    }
+    disposeTemplate(templateData) {
+        templateData.actionBar.dispose();
+    }
+};
+StackFramesRenderer.ID = 'stackFrame';
+StackFramesRenderer = ( __decorate([
+    ( __param(0, ILabelService)),
+    ( __param(1, INotificationService))
+], StackFramesRenderer));
+class ErrorsRenderer {
+    get templateId() {
+        return ErrorsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const label = dom.append(container, $('.error'));
+        return { label };
+    }
+    renderElement(element, index, data) {
+        const error = element.element;
+        data.label.textContent = error;
+        data.label.title = error;
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Method not implemented.');
+    }
+    disposeTemplate(templateData) {
+    }
+}
+ErrorsRenderer.ID = 'error';
+class LoadMoreRenderer {
+    constructor() { }
+    get templateId() {
+        return LoadMoreRenderer.ID;
+    }
+    renderTemplate(container) {
+        const label = dom.append(container, $('.load-all'));
+        label.style.color = asCssVariable(textLinkForeground);
+        return { label };
+    }
+    renderElement(element, index, data) {
+        data.label.textContent = LoadMoreRenderer.LABEL;
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Method not implemented.');
+    }
+    disposeTemplate(templateData) {
+    }
+}
+LoadMoreRenderer.ID = 'loadMore';
+LoadMoreRenderer.LABEL = ( localize('loadAllStackFrames', "Load More Stack Frames"));
+class ShowMoreRenderer {
+    constructor() { }
+    get templateId() {
+        return ShowMoreRenderer.ID;
+    }
+    renderTemplate(container) {
+        const label = dom.append(container, $('.show-more'));
+        label.style.color = asCssVariable(textLinkForeground);
+        return { label };
+    }
+    renderElement(element, index, data) {
+        const stackFrames = element.element;
+        if (stackFrames.every(sf => !!(sf.source && sf.source.origin && sf.source.origin === stackFrames[0].source.origin))) {
+            data.label.textContent = ( localize(
+                'showMoreAndOrigin',
+                "Show {0} More: {1}",
+                stackFrames.length,
+                stackFrames[0].source.origin
+            ));
+        }
+        else {
+            data.label.textContent = ( localize('showMoreStackFrames', "Show {0} More Stack Frames", stackFrames.length));
+        }
+    }
+    renderCompressedElements(node, index, templateData, height) {
+        throw new Error('Method not implemented.');
+    }
+    disposeTemplate(templateData) {
+    }
+}
+ShowMoreRenderer.ID = 'showMore';
+class CallStackDelegate {
+    getHeight(element) {
+        if (element instanceof StackFrame && element.presentationHint === 'label') {
+            return 16;
+        }
+        if (element instanceof ThreadAndSessionIds || element instanceof Array) {
+            return 16;
+        }
+        return 22;
+    }
+    getTemplateId(element) {
+        if (isDebugSession(element)) {
+            return SessionsRenderer.ID;
+        }
+        if (element instanceof Thread) {
+            return ThreadsRenderer.ID;
+        }
+        if (element instanceof StackFrame) {
+            return StackFramesRenderer.ID;
+        }
+        if (typeof element === 'string') {
+            return ErrorsRenderer.ID;
+        }
+        if (element instanceof ThreadAndSessionIds) {
+            return LoadMoreRenderer.ID;
+        }
+        return ShowMoreRenderer.ID;
+    }
+}
+function stoppedText(stoppedDetails) {
+    return stoppedDetails.text ?? stoppedDescription(stoppedDetails);
+}
+function stoppedDescription(stoppedDetails) {
+    return stoppedDetails.description ||
+        (stoppedDetails.reason ? ( localize(
+        { key: 'pausedOn', comment: ['indicates reason for program being paused'] },
+        "Paused on {0}",
+        stoppedDetails.reason
+    )) : ( localize('paused', "Paused")));
+}
+function isDebugModel(obj) {
+    return typeof obj.getSessions === 'function';
+}
+function isDebugSession(obj) {
+    return obj && typeof obj.getAllThreads === 'function';
+}
+function isDeemphasized(frame) {
+    return frame.source.presentationHint === 'deemphasize' || frame.presentationHint === 'deemphasize';
+}
+class CallStackDataSource {
+    constructor(debugService) {
+        this.debugService = debugService;
+        this.deemphasizedStackFramesToShow = [];
+    }
+    hasChildren(element) {
+        if (isDebugSession(element)) {
+            const threads = element.getAllThreads();
+            return (threads.length > 1) || (threads.length === 1 && threads[0].stopped) || !!(this.debugService.getModel().getSessions().find(s => s.parentSession === element));
+        }
+        return isDebugModel(element) || (element instanceof Thread && element.stopped);
+    }
+    async getChildren(element) {
+        if (isDebugModel(element)) {
+            const sessions = element.getSessions();
+            if (sessions.length === 0) {
+                return Promise.resolve([]);
+            }
+            if (sessions.length > 1 || this.debugService.getViewModel().isMultiSessionView()) {
+                return Promise.resolve(sessions.filter(s => !s.parentSession));
+            }
+            const threads = sessions[0].getAllThreads();
+            return threads.length === 1 ? this.getThreadChildren(threads[0]) : Promise.resolve(threads);
+        }
+        else if (isDebugSession(element)) {
+            const childSessions = this.debugService.getModel().getSessions().filter(s => s.parentSession === element);
+            const threads = element.getAllThreads();
+            if (threads.length === 1) {
+                const children = await this.getThreadChildren(threads[0]);
+                return children.concat(childSessions);
+            }
+            return Promise.resolve(threads.concat(childSessions));
+        }
+        else {
+            return this.getThreadChildren(element);
+        }
+    }
+    getThreadChildren(thread) {
+        return this.getThreadCallstack(thread).then(children => {
+            const result = [];
+            children.forEach((child, index) => {
+                if (child instanceof StackFrame && child.source && isDeemphasized(child)) {
+                    if (this.deemphasizedStackFramesToShow.indexOf(child) === -1) {
+                        if (result.length) {
+                            const last = result[result.length - 1];
+                            if (last instanceof Array) {
+                                last.push(child);
+                                return;
+                            }
+                        }
+                        const nextChild = index < children.length - 1 ? children[index + 1] : undefined;
+                        if (nextChild instanceof StackFrame && nextChild.source && isDeemphasized(nextChild)) {
+                            result.push([child]);
+                            return;
+                        }
+                    }
+                }
+                result.push(child);
+            });
+            return result;
+        });
+    }
+    async getThreadCallstack(thread) {
+        let callStack = thread.getCallStack();
+        if (!callStack || !callStack.length) {
+            await thread.fetchCallStack();
+            callStack = thread.getCallStack();
+        }
+        if (callStack.length === 1 && thread.session.capabilities.supportsDelayedStackTraceLoading && thread.stoppedDetails && thread.stoppedDetails.totalFrames && thread.stoppedDetails.totalFrames > 1) {
+            callStack = callStack.concat(thread.getStaleCallStack().slice(1));
+        }
+        if (thread.stoppedDetails && thread.stoppedDetails.framesErrorMessage) {
+            callStack = callStack.concat([thread.stoppedDetails.framesErrorMessage]);
+        }
+        if (!thread.reachedEndOfCallStack && thread.stoppedDetails) {
+            callStack = callStack.concat([( new ThreadAndSessionIds(thread.session.getId(), thread.threadId))]);
+        }
+        return callStack;
+    }
+}
+class CallStackAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localize(
+            { comment: ['Debug is a noun in this context, not a verb.'], key: 'callStackAriaLabel' },
+            "Debug Call Stack"
+        ));
+    }
+    getWidgetRole() {
+        return 'treegrid';
+    }
+    getRole(_element) {
+        return 'row';
+    }
+    getAriaLabel(element) {
+        if (element instanceof Thread) {
+            return ( localize(
+                { key: 'threadAriaLabel', comment: ['Placeholders stand for the thread name and the thread state.For example "Thread 1" and "Stopped'] },
+                "Thread {0} {1}",
+                element.name,
+                element.stateLabel
+            ));
+        }
+        if (element instanceof StackFrame) {
+            return ( localize(
+                'stackFrameAriaLabel',
+                "Stack Frame {0}, line {1}, {2}",
+                element.name,
+                element.range.startLineNumber,
+                getSpecificSourceName(element)
+            ));
+        }
+        if (isDebugSession(element)) {
+            const thread = element.getAllThreads().find(t => t.stopped);
+            const state = thread ? thread.stateLabel : ( localize({ key: 'running', comment: ['indicates state'] }, "Running"));
+            return ( localize(
+                { key: 'sessionLabel', comment: ['Placeholders stand for the session name and the session state. For example "Launch Program" and "Running"'] },
+                "Session {0} {1}",
+                element.getLabel(),
+                state
+            ));
+        }
+        if (typeof element === 'string') {
+            return element;
+        }
+        if (element instanceof Array) {
+            return ( localize('showMoreStackFrames', "Show {0} More Stack Frames", element.length));
+        }
+        return LoadMoreRenderer.LABEL;
+    }
+}
+class CallStackCompressionDelegate {
+    constructor(debugService) {
+        this.debugService = debugService;
+    }
+    isIncompressible(stat) {
+        if (isDebugSession(stat)) {
+            if (stat.compact) {
+                return false;
+            }
+            const sessions = this.debugService.getModel().getSessions();
+            if (( sessions.some(s => s.parentSession === stat && s.compact))) {
+                return false;
+            }
+            return true;
+        }
+        return true;
+    }
+}
+registerAction2(class Collapse extends ViewAction {
+    constructor() {
+        super({
+            id: 'callStack.collapse',
+            viewId: CALLSTACK_VIEW_ID,
+            title: ( localize('collapse', "Collapse All")),
+            f1: false,
+            icon: Codicon.collapseAll,
+            precondition: ( CONTEXT_DEBUG_STATE.isEqualTo(getStateLabel(2 ))),
+            menu: {
+                id: MenuId.ViewTitle,
+                order: 10,
+                group: 'navigation',
+                when: ( ContextKeyExpr.equals('view', CALLSTACK_VIEW_ID))
+            }
+        });
+    }
+    runInView(_accessor, view) {
+        view.collapseAll();
+    }
+});
+function registerCallStackInlineMenuItem(id, title, icon, when, order, precondition) {
+    MenuRegistry.appendMenuItem(MenuId.DebugCallStackContext, {
+        group: 'inline',
+        order,
+        when,
+        command: { id, title, icon, precondition }
+    });
+}
+const threadOrSessionWithOneThread = ( ContextKeyExpr.or(( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('thread')), ( ContextKeyExpr.and(( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')), CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD))));
+registerCallStackInlineMenuItem(PAUSE_ID, PAUSE_LABEL, debugPause, ( ContextKeyExpr.and(threadOrSessionWithOneThread, ( CONTEXT_CALLSTACK_ITEM_STOPPED.toNegated()))), 10);
+registerCallStackInlineMenuItem(CONTINUE_ID, CONTINUE_LABEL, debugContinue, ( ContextKeyExpr.and(threadOrSessionWithOneThread, CONTEXT_CALLSTACK_ITEM_STOPPED)), 10);
+registerCallStackInlineMenuItem(STEP_OVER_ID, STEP_OVER_LABEL, debugStepOver, threadOrSessionWithOneThread, 20, CONTEXT_CALLSTACK_ITEM_STOPPED);
+registerCallStackInlineMenuItem(STEP_INTO_ID, STEP_INTO_LABEL, debugStepInto, threadOrSessionWithOneThread, 30, CONTEXT_CALLSTACK_ITEM_STOPPED);
+registerCallStackInlineMenuItem(STEP_OUT_ID, STEP_OUT_LABEL, debugStepOut, threadOrSessionWithOneThread, 40, CONTEXT_CALLSTACK_ITEM_STOPPED);
+registerCallStackInlineMenuItem(RESTART_SESSION_ID, RESTART_LABEL, debugRestart, ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')), 50);
+registerCallStackInlineMenuItem(STOP_ID, STOP_LABEL, debugStop, ( ContextKeyExpr.and(( CONTEXT_CALLSTACK_SESSION_IS_ATTACH.toNegated()), ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')))), 60);
+registerCallStackInlineMenuItem(DISCONNECT_ID, DISCONNECT_LABEL, debugDisconnect, ( ContextKeyExpr.and(CONTEXT_CALLSTACK_SESSION_IS_ATTACH, ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('session')))), 60);
+export { CallStackView, getContext, getContextForContributedActions, getSpecificSourceName };