@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.1

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

@@ -0,0 +1,399 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/breakpointWidget.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { SelectBox } from 'monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.js';
+import * as lifecycle from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { ZoneWidget } from 'monaco-editor/esm/vs/editor/contrib/zoneWidget/browser/zoneWidget.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { CONTEXT_BREAKPOINT_WIDGET_VISIBLE, CONTEXT_IN_BREAKPOINT_WIDGET, BREAKPOINT_EDITOR_CONTRIBUTION_ID, DEBUG_SCHEME, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { EditorCommand, registerEditorCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { provideSuggestionItems, CompletionOptions } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { editorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { getSimpleCodeEditorWidgetOptions, getSimpleEditorOptions } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { defaultSelectBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+
+const $ = dom.$;
+const IPrivateBreakpointWidgetService = ( (createDecorator('privateBreakpointWidgetService')));
+const DECORATION_KEY = 'breakpointwidgetdecoration';
+function isPositionInCurlyBracketBlock(input) {
+    const model = input.getModel();
+    const bracketPairs = model.bracketPairs.getBracketPairsInRange(Range.fromPositions(input.getPosition()));
+    return (
+         (bracketPairs.some(p => p.openingBracketInfo.bracketText === '{'))
+    );
+}
+function createDecorations(theme, placeHolder) {
+    const transparentForeground = theme.getColor(editorForeground)?.transparent(0.4);
+    return [{
+            range: {
+                startLineNumber: 0,
+                endLineNumber: 0,
+                startColumn: 0,
+                endColumn: 1
+            },
+            renderOptions: {
+                after: {
+                    contentText: placeHolder,
+                    color: transparentForeground ? ( (transparentForeground.toString())) : undefined
+                }
+            }
+        }];
+}
+let BreakpointWidget = class BreakpointWidget extends ZoneWidget {
+    constructor(editor, lineNumber, column, context, contextViewService, debugService, themeService, contextKeyService, instantiationService, modelService, codeEditorService, _configurationService, languageFeaturesService, keybindingService) {
+        super(editor, { showFrame: true, showArrow: false, frameWidth: 1, isAccessible: true });
+        this.lineNumber = lineNumber;
+        this.column = column;
+        this.contextViewService = contextViewService;
+        this.debugService = debugService;
+        this.themeService = themeService;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.modelService = modelService;
+        this.codeEditorService = codeEditorService;
+        this._configurationService = _configurationService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.keybindingService = keybindingService;
+        this.conditionInput = '';
+        this.hitCountInput = '';
+        this.logMessageInput = '';
+        this.toDispose = [];
+        const model = this.editor.getModel();
+        if (model) {
+            const uri = model.uri;
+            const breakpoints = this.debugService.getModel().getBreakpoints({ lineNumber: this.lineNumber, column: this.column, uri });
+            this.breakpoint = breakpoints.length ? breakpoints[0] : undefined;
+        }
+        if (context === undefined) {
+            if (this.breakpoint && !this.breakpoint.condition && !this.breakpoint.hitCondition && this.breakpoint.logMessage) {
+                this.context = 2 ;
+            }
+            else if (this.breakpoint && !this.breakpoint.condition && this.breakpoint.hitCondition) {
+                this.context = 1 ;
+            }
+            else {
+                this.context = 0 ;
+            }
+        }
+        else {
+            this.context = context;
+        }
+        this.toDispose.push(this.debugService.getModel().onDidChangeBreakpoints(e => {
+            if (this.breakpoint && e && e.removed && e.removed.indexOf(this.breakpoint) >= 0) {
+                this.dispose();
+            }
+        }));
+        this.codeEditorService.registerDecorationType('breakpoint-widget', DECORATION_KEY, {});
+        this.create();
+    }
+    get placeholder() {
+        const acceptString = this.keybindingService.lookupKeybinding(AcceptBreakpointWidgetInputAction.ID)?.getLabel() || 'Enter';
+        const closeString = this.keybindingService.lookupKeybinding(CloseBreakpointWidgetCommand.ID)?.getLabel() || 'Escape';
+        switch (this.context) {
+            case 2 :
+                return (
+                     (nls.localize(
+                        'breakpointWidgetLogMessagePlaceholder',
+                        "Message to log when breakpoint is hit. Expressions within {} are interpolated. '{0}' to accept, '{1}' to cancel.",
+                        acceptString,
+                        closeString
+                    ))
+                );
+            case 1 :
+                return (
+                     (nls.localize(
+                        'breakpointWidgetHitCountPlaceholder',
+                        "Break when hit count condition is met. '{0}' to accept, '{1}' to cancel.",
+                        acceptString,
+                        closeString
+                    ))
+                );
+            default:
+                return (
+                     (nls.localize(
+                        'breakpointWidgetExpressionPlaceholder',
+                        "Break when expression evaluates to true. '{0}' to accept, '{1}' to cancel.",
+                        acceptString,
+                        closeString
+                    ))
+                );
+        }
+    }
+    getInputValue(breakpoint) {
+        switch (this.context) {
+            case 2 :
+                return breakpoint && breakpoint.logMessage ? breakpoint.logMessage : this.logMessageInput;
+            case 1 :
+                return breakpoint && breakpoint.hitCondition ? breakpoint.hitCondition : this.hitCountInput;
+            default:
+                return breakpoint && breakpoint.condition ? breakpoint.condition : this.conditionInput;
+        }
+    }
+    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;
+        }
+    }
+    setInputMode() {
+        if (this.editor.hasModel()) {
+            const languageId = this.context === 2  ? PLAINTEXT_LANGUAGE_ID : this.editor.getModel().getLanguageId();
+            this.input.getModel().setLanguage(languageId);
+        }
+    }
+    show(rangeOrPos) {
+        const lineNum = this.input.getModel().getLineCount();
+        super.show(rangeOrPos, lineNum + 1);
+    }
+    fitHeightToContent() {
+        const lineNum = this.input.getModel().getLineCount();
+        this._relayout(lineNum + 1);
+    }
+    _fillContainer(container) {
+        this.setCssClass('breakpoint-widget');
+        const selectBox = ( (new SelectBox(
+            [{ text: ( (nls.localize('expression', "Expression"))) }, { text: ( (nls.localize('hitCount', "Hit Count"))) }, { text: ( (nls.localize('logMessage', "Log Message"))) }],
+            this.context,
+            this.contextViewService,
+            defaultSelectBoxStyles,
+            { ariaLabel: ( (nls.localize('breakpointType', 'Breakpoint Type'))) }
+        )));
+        this.selectContainer = $('.breakpoint-select-container');
+        selectBox.render(dom.append(container, this.selectContainer));
+        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.inputContainer = $('.inputContainer');
+        this.createBreakpointInput(dom.append(container, this.inputContainer));
+        this.input.getModel().setValue(this.getInputValue(this.breakpoint));
+        this.toDispose.push(this.input.getModel().onDidChangeContent(() => {
+            this.fitHeightToContent();
+        }));
+        this.input.setPosition({ lineNumber: 1, column: this.input.getModel().getLineMaxColumn(1) });
+        setTimeout(() => this.input.focus(), 150);
+    }
+    _doLayout(heightInPixel, widthInPixel) {
+        this.heightInPx = heightInPixel;
+        this.input.layout({ height: heightInPixel, width: widthInPixel - 113 });
+        this.centerInputVertically();
+    }
+    _onWidth(widthInPixel) {
+        if (typeof this.heightInPx === 'number') {
+            this._doLayout(this.heightInPx, widthInPixel);
+        }
+    }
+    createBreakpointInput(container) {
+        const scopedContextKeyService = this.contextKeyService.createScoped(container);
+        this.toDispose.push(scopedContextKeyService);
+        const scopedInstatiationService = this.instantiationService.createChild(( (new ServiceCollection(
+            [IContextKeyService, scopedContextKeyService],
+            [IPrivateBreakpointWidgetService, this]
+        ))));
+        const options = this.createEditorOptions();
+        const codeEditorWidgetOptions = getSimpleCodeEditorWidgetOptions();
+        this.input = scopedInstatiationService.createInstance(CodeEditorWidget, container, options, codeEditorWidgetOptions);
+        CONTEXT_IN_BREAKPOINT_WIDGET.bindTo(scopedContextKeyService).set(true);
+        const model = this.modelService.createModel('', null, ( URI.parse(`${DEBUG_SCHEME}:${this.editor.getId()}:breakpointinput`)), true);
+        if (this.editor.hasModel()) {
+            model.setLanguage(this.editor.getModel().getLanguageId());
+        }
+        this.input.setModel(model);
+        this.setInputMode();
+        this.toDispose.push(model);
+        const setDecorations = () => {
+            const value = this.input.getModel().getValue();
+            const decorations = !!value ? [] : createDecorations(this.themeService.getColorTheme(), this.placeholder);
+            this.input.setDecorationsByType('breakpoint-widget', DECORATION_KEY, decorations);
+        };
+        this.input.getModel().onDidChangeContent(() => setDecorations());
+        this.themeService.onDidColorThemeChange(() => setDecorations());
+        this.toDispose.push(this.languageFeaturesService.completionProvider.register({ scheme: DEBUG_SCHEME, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'breakpointWidget',
+            provideCompletionItems: (model, position, _context, token) => {
+                let suggestionsPromise;
+                const underlyingModel = this.editor.getModel();
+                if (underlyingModel && (this.context === 0  || (this.context === 2  && isPositionInCurlyBracketBlock(this.input)))) {
+                    suggestionsPromise = provideSuggestionItems(this.languageFeaturesService.completionProvider, underlyingModel, ( (new Position(this.lineNumber, 1))), ( (new CompletionOptions(
+                        undefined,
+                        ( (new Set())).add(27 )
+                    ))), _context, token).then(suggestions => {
+                        let overwriteBefore = 0;
+                        if (this.context === 0 ) {
+                            overwriteBefore = position.column - 1;
+                        }
+                        else {
+                            const value = this.input.getModel().getValue();
+                            while ((position.column - 2 - overwriteBefore >= 0) && value[position.column - 2 - overwriteBefore] !== '{' && value[position.column - 2 - overwriteBefore] !== ' ') {
+                                overwriteBefore++;
+                            }
+                        }
+                        return {
+                            suggestions: ( (suggestions.items.map(s => {
+                                s.completion.range = Range.fromPositions(position.delta(0, -overwriteBefore), position);
+                                return s.completion;
+                            })))
+                        };
+                    });
+                }
+                else {
+                    suggestionsPromise = Promise.resolve({ suggestions: [] });
+                }
+                return suggestionsPromise;
+            }
+        }));
+        this.toDispose.push(this._configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('editor.fontSize') || e.affectsConfiguration('editor.lineHeight')) {
+                this.input.updateOptions(this.createEditorOptions());
+                this.centerInputVertically();
+            }
+        }));
+    }
+    createEditorOptions() {
+        const editorConfig = this._configurationService.getValue('editor');
+        const options = getSimpleEditorOptions(this._configurationService);
+        options.fontSize = editorConfig.fontSize;
+        options.fontFamily = editorConfig.fontFamily;
+        options.lineHeight = editorConfig.lineHeight;
+        options.fontLigatures = editorConfig.fontLigatures;
+        options.ariaLabel = this.placeholder;
+        return options;
+    }
+    centerInputVertically() {
+        if (this.container && typeof this.heightInPx === 'number') {
+            const lineHeight = this.input.getOption(65 );
+            const lineNum = this.input.getModel().getLineCount();
+            const newTopMargin = (this.heightInPx - lineNum * lineHeight) / 2;
+            this.inputContainer.style.marginTop = newTopMargin + 'px';
+        }
+    }
+    close(success) {
+        if (success) {
+            let condition = this.breakpoint && this.breakpoint.condition;
+            let hitCondition = this.breakpoint && this.breakpoint.hitCondition;
+            let logMessage = this.breakpoint && this.breakpoint.logMessage;
+            this.rememberInput();
+            if (this.conditionInput || this.context === 0 ) {
+                condition = this.conditionInput;
+            }
+            if (this.hitCountInput || this.context === 1 ) {
+                hitCondition = this.hitCountInput;
+            }
+            if (this.logMessageInput || this.context === 2 ) {
+                logMessage = this.logMessageInput;
+            }
+            if (this.breakpoint) {
+                const data = ( (new Map()));
+                data.set(this.breakpoint.getId(), {
+                    condition,
+                    hitCondition,
+                    logMessage
+                });
+                this.debugService.updateBreakpoints(this.breakpoint.originalUri, data, false).then(undefined, onUnexpectedError);
+            }
+            else {
+                const model = this.editor.getModel();
+                if (model) {
+                    this.debugService.addBreakpoints(model.uri, [{
+                            lineNumber: this.lineNumber,
+                            column: this.column,
+                            enabled: true,
+                            condition,
+                            hitCondition,
+                            logMessage
+                        }]);
+                }
+            }
+        }
+        this.dispose();
+    }
+    dispose() {
+        super.dispose();
+        this.input.dispose();
+        lifecycle.dispose(this.toDispose);
+        setTimeout(() => this.editor.focus(), 0);
+    }
+};
+BreakpointWidget = ( (__decorate([
+    ( (__param(4, IContextViewService))),
+    ( (__param(5, IDebugService))),
+    ( (__param(6, IThemeService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IInstantiationService))),
+    ( (__param(9, IModelService))),
+    ( (__param(10, ICodeEditorService))),
+    ( (__param(11, IConfigurationService))),
+    ( (__param(12, ILanguageFeaturesService))),
+    ( (__param(13, IKeybindingService)))
+], BreakpointWidget)));
+class AcceptBreakpointWidgetInputAction extends EditorCommand {
+    static { this.ID = 'breakpointWidget.action.acceptInput'; }
+    constructor() {
+        super({
+            id: AcceptBreakpointWidgetInputAction.ID,
+            precondition: CONTEXT_BREAKPOINT_WIDGET_VISIBLE,
+            kbOpts: {
+                kbExpr: CONTEXT_IN_BREAKPOINT_WIDGET,
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    runEditorCommand(accessor, editor) {
+        accessor.get(IPrivateBreakpointWidgetService).close(true);
+    }
+}
+class CloseBreakpointWidgetCommand extends EditorCommand {
+    static { this.ID = 'closeBreakpointWidget'; }
+    constructor() {
+        super({
+            id: CloseBreakpointWidgetCommand.ID,
+            precondition: CONTEXT_BREAKPOINT_WIDGET_VISIBLE,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 9 ,
+                secondary: [1024  | 9 ],
+                weight: 100
+            }
+        });
+    }
+    runEditorCommand(accessor, editor, args) {
+        const debugContribution = editor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID);
+        if (debugContribution) {
+            return debugContribution.closeBreakpointWidget();
+        }
+        accessor.get(IPrivateBreakpointWidgetService).close(false);
+    }
+}
+registerEditorCommand(( (new AcceptBreakpointWidgetInputAction())));
+registerEditorCommand(( (new CloseBreakpointWidgetCommand())));
+
+export { BreakpointWidget };