@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -0,0 +1,202 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, addDisposableListener, EventType, clearNode, addStandardDisposableListener, $ as $$1 } from '../../../../base/browser/dom.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { HighlightedLabel } from '../../../../base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { InputBox } from '../../../../base/browser/ui/inputbox/inputBox.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { createMatches } from '../../../../base/common/filters.js';
+import { createSingleCallFunction } from '../../../../base/common/functional.js';
+import { toDisposable, DisposableStore, dispose } from '../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { defaultInputBoxStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IDebugService } from '../common/debug.js';
+import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
+import { ReplEvaluationResult } from '../common/replModel.js';
+const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
+const booleanRegex = /^(true|false)$/i;
+const stringRegex = /^(['"]).*\1$/;
+const $ = $$1;
+function renderViewTree(container) {
+    const treeContainer = $('.');
+    treeContainer.classList.add('debug-view-content');
+    container.appendChild(treeContainer);
+    return treeContainer;
+}
+function renderExpressionValue(expressionOrValue, container, options) {
+    let value = typeof expressionOrValue === 'string' ? expressionOrValue : expressionOrValue.value;
+    container.className = 'value';
+    if (value === null || ((expressionOrValue instanceof Expression || expressionOrValue instanceof Variable || expressionOrValue instanceof ReplEvaluationResult) && !expressionOrValue.available)) {
+        container.classList.add('unavailable');
+        if (value !== Expression.DEFAULT_VALUE) {
+            container.classList.add('error');
+        }
+    }
+    else {
+        if (typeof expressionOrValue !== 'string' && options.showChanged && expressionOrValue.valueChanged && value !== Expression.DEFAULT_VALUE) {
+            container.className = 'value changed';
+            expressionOrValue.valueChanged = false;
+        }
+        if (options.colorize && typeof expressionOrValue !== 'string') {
+            if (expressionOrValue.type === 'number' || expressionOrValue.type === 'boolean' || expressionOrValue.type === 'string') {
+                container.classList.add(expressionOrValue.type);
+            }
+            else if (!isNaN(+value)) {
+                container.classList.add('number');
+            }
+            else if (booleanRegex.test(value)) {
+                container.classList.add('boolean');
+            }
+            else if (stringRegex.test(value)) {
+                container.classList.add('string');
+            }
+        }
+    }
+    if (options.maxValueLength && value && value.length > options.maxValueLength) {
+        value = value.substring(0, options.maxValueLength) + '...';
+    }
+    if (!value) {
+        value = '';
+    }
+    if (options.linkDetector) {
+        container.textContent = '';
+        const session = (expressionOrValue instanceof ExpressionContainer) ? expressionOrValue.getSession() : undefined;
+        container.appendChild(options.linkDetector.linkify(value, false, session ? session.root : undefined, true));
+    }
+    else {
+        container.textContent = value;
+    }
+    if (options.showHover) {
+        container.title = value || '';
+    }
+}
+function renderVariable(variable, data, showChanged, highlights, linkDetector) {
+    if (variable.available) {
+        let text = variable.name;
+        if (variable.value && typeof variable.name === 'string') {
+            text += ':';
+        }
+        data.label.set(text, highlights, variable.type ? variable.type : variable.name);
+        data.name.classList.toggle('virtual', variable.presentationHint?.kind === 'virtual');
+        data.name.classList.toggle('internal', variable.presentationHint?.visibility === 'internal');
+    }
+    else if (variable.value && typeof variable.name === 'string' && variable.name) {
+        data.label.set(':');
+    }
+    data.expression.classList.toggle('lazy', !!variable.presentationHint?.lazy);
+    renderExpressionValue(variable, data.value, {
+        showChanged,
+        maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
+        showHover: true,
+        colorize: true,
+        linkDetector
+    });
+}
+let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
+    constructor(debugService, contextViewService) {
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+    }
+    renderTemplate(container) {
+        const expression = append(container, $('.expression'));
+        const name = append(expression, $('span.name'));
+        const lazyButton = append(expression, $('span.lazy-button'));
+        lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
+        lazyButton.title = ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/baseDebugView',
+            'debug.lazyButton.tooltip',
+            "Click to expand"
+        ));
+        const value = append(expression, $('span.value'));
+        const label = ( new HighlightedLabel(name));
+        const inputBoxContainer = append(expression, $('.inputBoxContainer'));
+        const templateDisposable = ( new DisposableStore());
+        let actionBar;
+        if (this.renderActionBar) {
+            append(expression, $('.span.actionbar-spacer'));
+            actionBar = templateDisposable.add(( new ActionBar(expression)));
+        }
+        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: ( new DisposableStore()), templateDisposable, lazyButton, currentElement: undefined };
+        templateDisposable.add(addDisposableListener(lazyButton, EventType.CLICK, () => {
+            if (template.currentElement) {
+                this.debugService.getViewModel().evaluateLazyExpression(template.currentElement);
+            }
+        }));
+        return template;
+    }
+    renderExpressionElement(element, node, data) {
+        data.elementDisposable.clear();
+        data.currentElement = element;
+        this.renderExpression(node.element, data, createMatches(node.filterData));
+        if (data.actionBar) {
+            this.renderActionBar(data.actionBar, element, data);
+        }
+        const selectedExpression = this.debugService.getViewModel().getSelectedExpression();
+        if (element === selectedExpression?.expression || (element instanceof Variable && element.errorMessage)) {
+            const options = this.getInputBoxOptions(element, !!selectedExpression?.settingWatch);
+            if (options) {
+                data.elementDisposable.add(this.renderInputBox(data.name, data.value, data.inputBoxContainer, options));
+            }
+        }
+    }
+    renderInputBox(nameElement, valueElement, inputBoxContainer, options) {
+        nameElement.style.display = 'none';
+        valueElement.style.display = 'none';
+        inputBoxContainer.style.display = 'initial';
+        clearNode(inputBoxContainer);
+        const inputBox = ( new InputBox(
+            inputBoxContainer,
+            this.contextViewService,
+            { ...options, inputBoxStyles: defaultInputBoxStyles }
+        ));
+        inputBox.value = options.initialValue;
+        inputBox.focus();
+        inputBox.select();
+        const done = createSingleCallFunction((success, finishEditing) => {
+            nameElement.style.display = '';
+            valueElement.style.display = '';
+            inputBoxContainer.style.display = 'none';
+            const value = inputBox.value;
+            dispose(toDispose);
+            if (finishEditing) {
+                this.debugService.getViewModel().setSelectedExpression(undefined, false);
+                options.onFinish(value, success);
+            }
+        });
+        const toDispose = [
+            inputBox,
+            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_DOWN, (e) => {
+                const isEscape = e.equals(9 );
+                const isEnter = e.equals(3 );
+                if (isEscape || isEnter) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    done(isEnter, true);
+                }
+            }),
+            addDisposableListener(inputBox.inputElement, EventType.BLUR, () => {
+                done(true, true);
+            }),
+            addDisposableListener(inputBox.inputElement, EventType.CLICK, e => {
+                e.preventDefault();
+                e.stopPropagation();
+            })
+        ];
+        return toDisposable(() => {
+            done(false, false);
+        });
+    }
+    disposeElement(node, index, templateData) {
+        templateData.elementDisposable.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposable.dispose();
+        templateData.templateDisposable.dispose();
+    }
+};
+AbstractExpressionsRenderer = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IContextViewService))
+], AbstractExpressionsRenderer));
+export { AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree };

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointEditorContribution.js

@@ -38,6 +38,11 @@ const breakpointHelperDecoration = {
     description: 'breakpoint-helper-decoration',
     glyphMarginClassName: ThemeIcon.asClassName(debugBreakpointHint),
     glyphMargin: { position: GlyphMarginLane.Right },
+    glyphMarginHoverMessage: ( new MarkdownString()).appendText(( localizeWithPath(
+        'vs/workbench/contrib/debug/browser/breakpointEditorContribution',
+        'breakpointHelper',
+        "Click to add a breakpoint."
+    ))),
     stickiness: 1
 };
 function createBreakpointDecorations(accessor, model, breakpoints, state, breakpointsActivated, showBreakpointsInOverviewRuler) {
@@ -66,7 +71,8 @@ function createBreakpointDecorations(accessor, model, breakpoints, state, breakp
 function getBreakpointDecorationOptions(accessor, model, breakpoint, state, breakpointsActivated, showBreakpointsInOverviewRuler, hasOtherBreakpointsOnLine) {
     const debugService = accessor.get(IDebugService);
     const languageService = accessor.get(ILanguageService);
-    const { icon, message, showAdapterUnverifiedMessage } = getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint, undefined);
+    const labelService = accessor.get(ILabelService);
+    const { icon, message, showAdapterUnverifiedMessage } = getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint, labelService, debugService.getModel());
     let glyphMarginHoverMessage;
     let unverifiedMessage;
     if (showAdapterUnverifiedMessage) {
@@ -233,7 +239,9 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
                     if (isShiftPressed) {
                         breakpoints.forEach(bp => this.debugService.enableOrDisableBreakpoints(!enabled, bp));
                     }
-                    else if (!isLinux && ( breakpoints.some(bp => !!bp.condition || !!bp.logMessage || !!bp.hitCondition))) {
+                    else if (!isLinux && ( breakpoints.some(
+                        bp => !!bp.condition || !!bp.logMessage || !!bp.hitCondition || !!bp.triggeredBy
+                    ))) {
                         const logPoint = breakpoints.every(bp => !!bp.logMessage);
                         const breakpointType = logPoint ? ( localizeWithPath(
                             'vs/workbench/contrib/debug/browser/breakpointEditorContribution',
@@ -485,6 +493,11 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
                 'addLogPoint',
                 "Add Logpoint..."
             )), undefined, true, () => Promise.resolve(this.showBreakpointWidget(lineNumber, column, 2 )))));
+            actions.push(( new Action('addTriggeredBreakpoint', ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointEditorContribution',
+                'addTriggeredBreakpoint',
+                "Add Triggered Breakpoint..."
+            )), undefined, true, () => Promise.resolve(this.showBreakpointWidget(lineNumber, column, 3 )))));
         }
         if (this.debugService.state === 2 ) {
             actions.push(( new Separator()));
@@ -501,7 +514,11 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
         if (decorations) {
             for (const { options } of decorations) {
                 const clz = options.glyphMarginClassName;
-                if (clz && (!clz.includes('codicon-') || clz.includes('codicon-testing-') || clz.includes('codicon-merge-') || clz.includes('codicon-arrow-') || clz.includes('codicon-loading') || clz.includes('codicon-fold') || clz.includes('codicon-inline-chat'))) {
+                if (!clz) {
+                    continue;
+                }
+                const hasSomeActionableCodicon = !(clz.includes('codicon-') || clz.startsWith('coverage-deco-')) || clz.includes('codicon-testing-') || clz.includes('codicon-merge-') || clz.includes('codicon-arrow-') || clz.includes('codicon-loading') || clz.includes('codicon-fold') || clz.includes('codicon-inline-chat');
+                if (hasSomeActionableCodicon) {
                     return false;
                 }
             }
@@ -536,7 +553,7 @@ let BreakpointEditorContribution = class BreakpointEditorContribution {
             });
             this.candidateDecorations = ( candidateDecorationIds.map((decorationId, index) => {
                 const candidate = desiredCandidateDecorations[index];
-                const icon = candidate.breakpoint ? getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), candidate.breakpoint, this.labelService).icon : breakpoint.disabled;
+                const icon = candidate.breakpoint ? getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), candidate.breakpoint, this.labelService, this.debugService.getModel()).icon : breakpoint.disabled;
                 const contextMenuActions = () => this.getContextMenuActions(candidate.breakpoint ? [candidate.breakpoint] : [], activeCodeEditor.getModel().uri, candidate.range.startLineNumber, candidate.range.startColumn);
                 const inlineWidget = ( new InlineBreakpointWidget(
                     activeCodeEditor,
@@ -792,6 +809,12 @@ registerThemingParticipant((theme, collector) => {
 			color: ${debugIconBreakpointColor} !important;
 		}
 		`);
+        collector.addRule(`
+		.monaco-workbench ${ThemeIcon.asCSSSelector(breakpoint.pending)} {
+			color: ${debugIconBreakpointColor} !important;
+			font-size: 12px !important;
+		}
+		`);
     }
     const debugIconBreakpointDisabledColor = theme.getColor(debugIconBreakpointDisabledForeground);
     if (debugIconBreakpointDisabledColor) {

package/vscode/src/vs/workbench/contrib/debug/browser/breakpointWidget.js

@@ -1,33 +1,37 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/breakpointWidget.css.js';
-import { localizeWithPath } from '../../../../nls.js';
+import { append, addDisposableListener, EventType, $ as $$1 } from '../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
 import { SelectBox } from '../../../../base/browser/ui/selectBox/selectBox.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { dispose } from '../../../../base/common/lifecycle.js';
-import { append, $ as $$1 } from '../../../../base/browser/dom.js';
-import { Position } from '../../../../editor/common/core/position.js';
-import { ZoneWidget } from '../../../../editor/contrib/zoneWidget/browser/zoneWidget.js';
-import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
-import { CONTEXT_BREAKPOINT_WIDGET_VISIBLE, CONTEXT_IN_BREAKPOINT_WIDGET, BREAKPOINT_EDITOR_CONTRIBUTION_ID, DEBUG_SCHEME, IDebugService } from '../common/debug.js';
-import { IThemeService } from '../../../../platform/theme/common/themeService.js';
-import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { EditorCommand, registerEditorCommand } from '../../../../editor/browser/editorExtensions.js';
-import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
-import { IModelService } from '../../../../editor/common/services/model.js';
 import { URI } from '../../../../base/common/uri.js';
-import { provideSuggestionItems, CompletionOptions } from '../../../../editor/contrib/suggest/browser/suggest.js';
+import './media/breakpointWidget.css.js';
+import { EditorCommand, registerEditorCommand } from '../../../../editor/browser/editorExtensions.js';
 import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
-import { editorForeground } from '../../../../platform/theme/common/colorRegistry.js';
-import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
 import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditorWidget.js';
-import { getSimpleCodeEditorWidgetOptions, getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { Position } from '../../../../editor/common/core/position.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../../../../editor/common/languages/modesRegistry.js';
 import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
-import { defaultSelectBoxStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { provideSuggestionItems, CompletionOptions } from '../../../../editor/contrib/suggest/browser/suggest.js';
+import { ZoneWidget } from '../../../../editor/contrib/zoneWidget/browser/zoneWidget.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextViewService } from '../../../../platform/contextview/browser/contextView.js';
+import { createDecorator, IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { defaultSelectBoxStyles, defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { editorForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { getSimpleCodeEditorWidgetOptions, getSimpleEditorOptions } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { CONTEXT_BREAKPOINT_WIDGET_VISIBLE, CONTEXT_IN_BREAKPOINT_WIDGET, BREAKPOINT_EDITOR_CONTRIBUTION_ID, DEBUG_SCHEME, IDebugService } from '../common/debug.js';
 const $ = $$1;
 const IPrivateBreakpointWidgetService = ( (createDecorator('privateBreakpointWidgetService')));
 const DECORATION_KEY = 'breakpointwidgetdecoration';
@@ -56,7 +60,7 @@ function createDecorations(theme, placeHolder) {
         }];
 }
 let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
-    constructor(editor, lineNumber, column, context, contextViewService, debugService, themeService, contextKeyService, instantiationService, modelService, codeEditorService, _configurationService, languageFeaturesService, keybindingService) {
+    constructor(editor, lineNumber, column, context, contextViewService, debugService, themeService, contextKeyService, instantiationService, modelService, codeEditorService, _configurationService, languageFeaturesService, keybindingService, labelService, textModelService) {
         super(editor, { showFrame: true, showArrow: false, frameWidth: 1, isAccessible: true });
         this.lineNumber = lineNumber;
         this.column = column;
@@ -70,6 +74,8 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
         this._configurationService = _configurationService;
         this.languageFeaturesService = languageFeaturesService;
         this.keybindingService = keybindingService;
+        this.labelService = labelService;
+        this.textModelService = textModelService;
         this.conditionInput = '';
         this.hitCountInput = '';
         this.logMessageInput = '';
@@ -87,6 +93,9 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
             else if (this.breakpoint && !this.breakpoint.condition && this.breakpoint.hitCondition) {
                 this.context = 1 ;
             }
+            else if (this.breakpoint && this.breakpoint.triggeredBy) {
+                this.context = 3 ;
+            }
             else {
                 this.context = 0 ;
             }
@@ -149,16 +158,18 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
         }
     }
     rememberInput() {
-        const value = this.input.getModel().getValue();
-        switch (this.context) {
-            case 2 :
-                this.logMessageInput = value;
-                break;
-            case 1 :
-                this.hitCountInput = value;
-                break;
-            default:
-                this.conditionInput = value;
+        if (this.context !== 3 ) {
+            const value = this.input.getModel().getValue();
+            switch (this.context) {
+                case 2 :
+                    this.logMessageInput = value;
+                    break;
+                case 1 :
+                    this.hitCountInput = value;
+                    break;
+                default:
+                    this.conditionInput = value;
+            }
         }
     }
     setInputMode() {
@@ -177,19 +188,28 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
     }
     _fillContainer(container) {
         this.setCssClass('breakpoint-widget');
-        const selectBox = ( (new SelectBox([{ text: ( (localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointWidget',
-            'expression',
-            "Expression"
-        ))) }, { text: ( (localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointWidget',
-            'hitCount',
-            "Hit Count"
-        ))) }, { text: ( (localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointWidget',
-            'logMessage',
-            "Log Message"
-        ))) }], this.context, this.contextViewService, defaultSelectBoxStyles, { ariaLabel: ( (localizeWithPath(
+        const selectBox = ( (new SelectBox([
+            { text: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointWidget',
+                'expression',
+                "Expression"
+            ))) },
+            { text: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointWidget',
+                'hitCount',
+                "Hit Count"
+            ))) },
+            { text: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointWidget',
+                'logMessage',
+                "Log Message"
+            ))) },
+            { text: ( (localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointWidget',
+                'triggeredBy',
+                "Wait for Breakpoint"
+            ))) },
+        ], this.context, this.contextViewService, defaultSelectBoxStyles, { ariaLabel: ( (localizeWithPath(
             'vs/workbench/contrib/debug/browser/breakpointWidget',
             'breakpointType',
             'Breakpoint Type'
@@ -199,10 +219,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
         selectBox.onDidSelect(e => {
             this.rememberInput();
             this.context = e.index;
-            this.setInputMode();
-            const value = this.getInputValue(this.breakpoint);
-            this.input.getModel().setValue(value);
-            this.input.focus();
+            this.updateContextInput();
         });
         this.inputContainer = $('.inputContainer');
         this.createBreakpointInput(append(container, this.inputContainer));
@@ -211,7 +228,84 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
             this.fitHeightToContent();
         }));
         this.input.setPosition({ lineNumber: 1, column: this.input.getModel().getLineMaxColumn(1) });
-        setTimeout(() => this.input.focus(), 150);
+        this.createTriggerBreakpointInput(container);
+        this.updateContextInput();
+        setTimeout(() => this.focusInput(), 150);
+    }
+    createTriggerBreakpointInput(container) {
+        const breakpoints = this.debugService.getModel().getBreakpoints().filter(bp => bp !== this.breakpoint);
+        const index = breakpoints.findIndex((bp) => this.breakpoint?.triggeredBy === bp.getId());
+        let select = 0;
+        if (index > -1) {
+            select = index + 1;
+        }
+        Promise.all(( (breakpoints.map(async (bp) => ({
+            text: `${this.labelService.getUriLabel(bp.uri, { relative: true })}: ${bp.lineNumber}`,
+            description: await this.textModelService.createModelReference(bp.uri).then(ref => {
+                try {
+                    return ref.object.textEditorModel.getLineContent(bp.lineNumber).trim();
+                }
+                finally {
+                    ref.dispose();
+                }
+            }, () => undefined),
+        }))))).then(breakpoints => {
+            selectBreakpointBox.setOptions([
+                { text: ( (localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointWidget',
+                    'noTriggerByBreakpoint',
+                    'None'
+                ))) },
+                ...breakpoints
+            ], select);
+        });
+        const selectBreakpointBox = this.selectBreakpointBox = ( (new SelectBox([{ text: ( (localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointWidget',
+            'triggerByLoading',
+            'Loading...'
+        ))), isDisabled: true }], 0, this.contextViewService, defaultSelectBoxStyles, { ariaLabel: ( (localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointWidget',
+            'selectBreakpoint',
+            'Select breakpoint'
+        ))) })));
+        selectBreakpointBox.onDidSelect(e => {
+            if (e.index === 0) {
+                this.triggeredByBreakpointInput = undefined;
+            }
+            else {
+                this.triggeredByBreakpointInput = breakpoints[e.index - 1];
+            }
+        });
+        this.toDispose.push(selectBreakpointBox);
+        this.selectBreakpointContainer = $('.select-breakpoint-container');
+        this.toDispose.push(addDisposableListener(this.selectBreakpointContainer, EventType.KEY_DOWN, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            if (event.equals(9 )) {
+                this.close(false);
+            }
+        }));
+        const selectionWrapper = $('.select-box-container');
+        append(this.selectBreakpointContainer, selectionWrapper);
+        selectBreakpointBox.render(selectionWrapper);
+        append(container, this.selectBreakpointContainer);
+        const closeButton = ( (new Button(this.selectBreakpointContainer, defaultButtonStyles)));
+        closeButton.label = ( (localizeWithPath('vs/workbench/contrib/debug/browser/breakpointWidget', 'ok', "Ok")));
+        this.toDispose.push(closeButton.onDidClick(() => this.close(true)));
+        this.toDispose.push(closeButton);
+    }
+    updateContextInput() {
+        if (this.context === 3 ) {
+            this.inputContainer.hidden = true;
+            this.selectBreakpointContainer.hidden = false;
+        }
+        else {
+            this.inputContainer.hidden = false;
+            this.selectBreakpointContainer.hidden = true;
+            this.setInputMode();
+            const value = this.getInputValue(this.breakpoint);
+            this.input.getModel().setValue(value);
+            this.focusInput();
+        }
     }
     _doLayout(heightInPixel, widthInPixel) {
         this.heightInPx = heightInPixel;
@@ -312,6 +406,7 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
             let condition = this.breakpoint && this.breakpoint.condition;
             let hitCondition = this.breakpoint && this.breakpoint.hitCondition;
             let logMessage = this.breakpoint && this.breakpoint.logMessage;
+            let triggeredBy = this.breakpoint && this.breakpoint.triggeredBy;
             this.rememberInput();
             if (this.conditionInput || this.context === 0 ) {
                 condition = this.conditionInput;
@@ -322,12 +417,19 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
             if (this.logMessageInput || this.context === 2 ) {
                 logMessage = this.logMessageInput;
             }
+            if (this.context === 3 ) {
+                condition = undefined;
+                hitCondition = undefined;
+                logMessage = undefined;
+                triggeredBy = this.triggeredByBreakpointInput?.getId();
+            }
             if (this.breakpoint) {
                 const data = ( (new Map()));
                 data.set(this.breakpoint.getId(), {
                     condition,
                     hitCondition,
-                    logMessage
+                    logMessage,
+                    triggeredBy
                 });
                 this.debugService.updateBreakpoints(this.breakpoint.originalUri, data, false).then(undefined, onUnexpectedError);
             }
@@ -340,13 +442,22 @@ let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
                             enabled: true,
                             condition,
                             hitCondition,
-                            logMessage
+                            logMessage,
+                            triggeredBy
                         }]);
                 }
             }
         }
         this.dispose();
     }
+    focusInput() {
+        if (this.context === 3 ) {
+            this.selectBreakpointBox.focus();
+        }
+        else {
+            this.input.focus();
+        }
+    }
     dispose() {
         super.dispose();
         this.input.dispose();
@@ -364,7 +475,9 @@ BreakpointWidget = ( (__decorate([
     ( (__param(10, ICodeEditorService))),
     ( (__param(11, IConfigurationService))),
     ( (__param(12, ILanguageFeaturesService))),
-    ( (__param(13, IKeybindingService)))
+    ( (__param(13, IKeybindingService))),
+    ( (__param(14, ILabelService))),
+    ( (__param(15, ITextModelService)))
 ], BreakpointWidget)));
 class AcceptBreakpointWidgetInputAction extends EditorCommand {
     static { this.ID = 'breakpointWidget.action.acceptInput'; }