@opensumi/ide-debug 2.12.1-next-079c1930

package/lib/browser/editor/debug-model.js

@@ -0,0 +1,673 @@
+"use strict";
+var DebugModel_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugModel = void 0;
+const tslib_1 = require("tslib");
+const monaco = (0, tslib_1.__importStar)(require("@opensumi/monaco-editor-core/esm/vs/editor/editor.api"));
+const ide_core_common_1 = require("@opensumi/ide-core-common");
+const di_1 = require("@opensumi/di");
+const debug_session_manager_1 = require("../debug-session-manager");
+const debug_breakpoint_widget_1 = require("./debug-breakpoint-widget");
+const breakpoint_1 = require("../breakpoint");
+const debug_editor_1 = require("../../common/debug-editor");
+const debug_session_1 = require("../../common/debug-session");
+const debug_hover_widget_1 = require("./debug-hover-widget");
+const debounce = require("lodash.debounce");
+const options = (0, tslib_1.__importStar)(require("./debug-styles"));
+const breakpoint_2 = require("../breakpoint");
+const common_1 = require("../../common");
+const next_1 = require("@opensumi/ide-core-browser/lib/menu/next");
+const ide_core_browser_1 = require("@opensumi/ide-core-browser");
+const breakpoint_decoration_1 = require("../breakpoint/breakpoint-decoration");
+let DebugModel = DebugModel_1 = class DebugModel {
+    constructor() {
+        this.toDispose = new ide_core_common_1.DisposableCollection();
+        this.frameDecorations = [];
+        this.updatingDecorations = false;
+        this.breakpointDecorations = [];
+        this.breakpointRanges = new Map();
+        this.currentBreakpointDecorations = [];
+        this.candidateDecorations = [];
+        /**
+         * 渲染当前堆栈对应的装饰器
+         *
+         * @protected
+         * @type {*}
+         * @memberof DebugModel
+         */
+        this.renderFrames = debounce(() => {
+            var _a;
+            if (this.toDispose.disposed) {
+                return;
+            }
+            if (((_a = this.editor.getModel()) === null || _a === void 0 ? void 0 : _a.uri.toString()) !== this.uri.toString()) {
+                return;
+            }
+            const decorations = this.createFrameDecorations();
+            this.frameDecorations = this.deltaDecorations(this.frameDecorations, decorations);
+        }, 100);
+        /**
+         * 断点开关函数
+         * @memberof DebugModel
+         */
+        this.toggleBreakpoint = (position = this.position) => {
+            this.doToggleBreakpoint(position);
+        };
+        this.openBreakpointView = (position, context, defaultContext) => {
+            this.breakpointWidget.show(position, context, defaultContext);
+        };
+        this.closeBreakpointView = () => {
+            this.breakpointWidget.hide();
+        };
+        this.acceptBreakpoint = () => {
+            const { position, values } = this.breakpointWidget;
+            this.reporterService.point(common_1.DEBUG_REPORT_NAME === null || common_1.DEBUG_REPORT_NAME === void 0 ? void 0 : common_1.DEBUG_REPORT_NAME.DEBUG_BREAKPOINT, this.breakpointWidget.breakpointType);
+            if (position && values) {
+                const breakpoint = this.getBreakpoint(position);
+                if (breakpoint) {
+                    breakpoint.raw.condition = values.condition;
+                    breakpoint.raw.hitCondition = values.hitCondition;
+                    breakpoint.raw.logMessage = values.logMessage;
+                    this.breakpointManager.updateBreakpoint(breakpoint);
+                }
+                else {
+                    this.breakpointManager.addBreakpoint(breakpoint_2.DebugBreakpoint.create(this.uri, Object.assign({ line: position.lineNumber }, values)));
+                }
+                this.breakpointWidget.hide();
+            }
+        };
+        this.hintDecorations = [];
+        this.init();
+    }
+    static createContainer(injector, editor) {
+        const child = injector.createChild([
+            {
+                token: debug_editor_1.DebugEditor,
+                useValue: editor,
+            },
+            {
+                token: debug_hover_widget_1.DebugHoverWidget,
+                useClass: debug_hover_widget_1.DebugHoverWidget,
+            },
+            {
+                token: debug_breakpoint_widget_1.DebugBreakpointWidget,
+                useClass: debug_breakpoint_widget_1.DebugBreakpointWidget,
+            },
+            {
+                token: common_1.IDebugModel,
+                useClass: DebugModel_1,
+            },
+        ]);
+        return child;
+    }
+    static createModel(injector, editor) {
+        return DebugModel_1.createContainer(injector, editor).get(common_1.IDebugModel);
+    }
+    async init() {
+        const model = this.editor.getModel();
+        this.uri = new ide_core_common_1.URI(model.uri.toString());
+        this.decorator = new breakpoint_decoration_1.DebugDecorator();
+        this.toDispose.pushAll([
+            this.breakpointWidget,
+            this.editor.onKeyDown(() => this.debugHoverWidget.hide({ immediate: false })),
+            this.editor.onDidChangeModelContent(() => this.renderFrames()),
+            this.debugSessionManager.onDidChange(() => this.renderFrames()),
+            this.editor.getModel().onDidChangeContent(() => this.updateBreakpoints()),
+            this.editor.onDidChangeModel(() => {
+                this.closeBreakpointView();
+            }),
+        ]);
+        this.renderFrames();
+        this.render();
+    }
+    dispose() {
+        this.toDispose.dispose();
+    }
+    get position() {
+        return this._position || this.editor.getPosition();
+    }
+    get breakpoint() {
+        return this.getBreakpoint();
+    }
+    getBreakpoint(position = this.position) {
+        return this.breakpointManager.getBreakpoint(this.uri, position.lineNumber);
+    }
+    /**
+     * 根据当前堆栈信息生成对应的编辑器装饰器描述
+     */
+    createFrameDecorations() {
+        var _a;
+        const decorations = [];
+        const { currentFrame, topFrame } = this.debugSessionManager;
+        if (!currentFrame || !currentFrame.source || currentFrame.source.uri.toString() !== ((_a = this.editor.getModel()) === null || _a === void 0 ? void 0 : _a.uri.toString())) {
+            return decorations;
+        }
+        // tslint:disable-next-line:no-bitwise
+        const columnUntilEOLRange = new monaco.Range(currentFrame.raw.line, currentFrame.raw.column, currentFrame.raw.line, 1 << 30);
+        const range = new monaco.Range(currentFrame.raw.line, currentFrame.raw.column, currentFrame.raw.line, currentFrame.raw.column + 1);
+        if (topFrame === currentFrame) {
+            decorations.push({
+                options: options.TOP_STACK_FRAME_MARGIN,
+                range,
+            });
+            if (currentFrame.thread.stoppedDetails && currentFrame.thread.stoppedDetails.reason === 'exception') {
+                decorations.push({
+                    options: options.TOP_STACK_FRAME_EXCEPTION_DECORATION,
+                    range: columnUntilEOLRange,
+                });
+            }
+            else {
+                decorations.push({
+                    options: options.TOP_STACK_FRAME_DECORATION,
+                    range: columnUntilEOLRange,
+                });
+                const { topFrameRange } = this;
+                if (topFrameRange && topFrameRange.startLineNumber === currentFrame.raw.line && topFrameRange.startColumn !== currentFrame.raw.column) {
+                    decorations.push({
+                        options: options.TOP_STACK_FRAME_INLINE_DECORATION,
+                        range: columnUntilEOLRange,
+                    });
+                }
+                this.topFrameRange = columnUntilEOLRange;
+            }
+        }
+        else {
+            decorations.push({
+                options: options.FOCUSED_STACK_FRAME_MARGIN,
+                range,
+            });
+            decorations.push({
+                options: options.FOCUSED_STACK_FRAME_DECORATION,
+                range: columnUntilEOLRange,
+            });
+        }
+        return decorations;
+    }
+    /**
+     * 根据传入的装饰器修饰编辑器界面
+     * @param oldDecorations
+     * @param newDecorations
+     */
+    deltaDecorations(oldDecorations, newDecorations) {
+        this.updatingDecorations = true;
+        try {
+            return this.editor.deltaDecorations(oldDecorations, newDecorations);
+        }
+        finally {
+            this.updatingDecorations = false;
+        }
+    }
+    /**
+     * 装饰堆栈文件
+     * @param {DebugStackFrame} frame
+     * @memberof DebugModel
+     */
+    focusStackFrame(frame) {
+        this.renderFrames();
+    }
+    render() {
+        this.renderBreakpoints();
+        this.renderFrames();
+    }
+    /**
+     * 渲染断点信息装饰器
+     * @memberof DebugModel
+     */
+    renderBreakpoints() {
+        this.renderNormalBreakpoints();
+        this.renderCurrentBreakpoints();
+    }
+    /**
+     * 渲染所有断点
+     * @protected
+     * @memberof DebugModel
+     */
+    renderNormalBreakpoints() {
+        const decorations = this.createBreakpointDecorations();
+        this.breakpointDecorations = this.deltaDecorations(this.breakpointDecorations, decorations);
+        this.updateBreakpointRanges();
+    }
+    updateBreakpoints() {
+        if (this.areBreakpointsAffected()) {
+            const breakpoints = this.createBreakpoints();
+            this.breakpointManager.setBreakpoints(this.uri, breakpoints);
+        }
+    }
+    areBreakpointsAffected() {
+        if (this.updatingDecorations || !this.editor.getModel()) {
+            return false;
+        }
+        for (const decoration of this.breakpointDecorations) {
+            const range = this.editor.getModel().getDecorationRange(decoration);
+            const oldRange = this.breakpointRanges.get(decoration);
+            if (!range || !range.equalsRange(oldRange)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 创建断点
+     * @protected
+     * @returns {DebugBreakpoint[]}
+     * @memberof DebugModel
+     */
+    createBreakpoints() {
+        const { uri } = this;
+        const lines = new Set();
+        const breakpoints = [];
+        for (const decoration of this.breakpointDecorations) {
+            const range = this.editor.getModel().getDecorationRange(decoration);
+            if (range && !lines.has(range.startLineNumber)) {
+                const line = range.startLineNumber;
+                const oldRange = this.breakpointRanges.get(decoration);
+                const oldBreakpoint = oldRange && this.breakpointManager.getBreakpoint(uri, oldRange.startLineNumber) || {};
+                const breakpoint = breakpoint_2.DebugBreakpoint.create(uri, Object.assign(Object.assign({}, (oldBreakpoint.raw || {})), { line }), oldBreakpoint.enabled);
+                breakpoints.push(breakpoint);
+                lines.add(line);
+            }
+        }
+        return breakpoints;
+    }
+    /**
+     * 生成多个断点的装饰器数组
+     * @protected
+     * @returns {monaco.editor.IModelDeltaDecoration[]}
+     * @memberof DebugModel
+     */
+    createBreakpointDecorations() {
+        const breakpoints = this.breakpointManager.getBreakpoints(this.uri);
+        return breakpoints.map((breakpoint) => this.createBreakpointDecoration(breakpoint));
+    }
+    /**
+     * 根据断点生成装饰器
+     * @protected
+     * @param {DebugBreakpoint} breakpoint
+     * @returns {monaco.editor.IModelDeltaDecoration}
+     * @memberof DebugModel
+     */
+    createBreakpointDecoration(breakpoint) {
+        const lineNumber = breakpoint.raw.line;
+        const column = breakpoint.raw.column || 1;
+        const range = new monaco.Range(lineNumber, column, lineNumber, column + 1);
+        return {
+            range,
+            options: {
+                description: 'breakpoint-decoration',
+                stickiness: options.STICKINESS,
+            },
+        };
+    }
+    /**
+     * 渲染当前命中的断点装饰器
+     * @protected
+     * @memberof DebugModel
+     */
+    async renderCurrentBreakpoints() {
+        const breakpoints = this.breakpointManager.getBreakpoints(this.uri);
+        const decorations = this.createCurrentBreakpointDecorations();
+        const decorationIds = this.deltaDecorations(this.currentBreakpointDecorations.map(({ decorationId }) => decorationId), decorations);
+        this.currentBreakpointDecorations.forEach((item) => {
+            if (item.inlineWidget) {
+                item.inlineWidget.dispose();
+            }
+        });
+        this.currentBreakpointDecorations = decorationIds.map((decorationId, index) => {
+            const decoration = decorations[index];
+            const breakpoint = breakpoints[index];
+            const icon = (breakpoint.enabled ? options.BREAKPOINT_DECORATION : options.BREAKPOINT_DECORATION_DISABLED).glyphMarginClassName;
+            const inlineWidget = decoration.options.beforeContentClassName ? new InlineBreakpointWidget(this.editor, decorationId, icon, breakpoint, this.breakpointManager) : undefined;
+            return {
+                breakpoint,
+                decorationId,
+                inlineWidget,
+            };
+        });
+        const desiredCandidateDecorations = await this.getCandidateBreakpoints(breakpoints);
+        const candidateDecorationIds = this.deltaDecorations(this.candidateDecorations.map(({ decorationId }) => decorationId), desiredCandidateDecorations);
+        this.candidateDecorations.forEach((candidate) => {
+            candidate.inlineWidget.dispose();
+        });
+        this.candidateDecorations = candidateDecorationIds.map((decorationId, index) => {
+            const { breakpoint } = desiredCandidateDecorations[index];
+            const icon = (breakpoint ? options.BREAKPOINT_DECORATION : options.BREAKPOINT_DECORATION_DISABLED).glyphMarginClassName;
+            const inlineWidget = new InlineBreakpointWidget(this.editor, decorationId, icon, breakpoint, this.breakpointManager);
+            return {
+                decorationId,
+                inlineWidget,
+            };
+        });
+    }
+    async getCandidateBreakpoints(breakpoints) {
+        const model = this.editor.getModel();
+        const session = this.debugSessionManager.currentSession;
+        if (!model || !(session === null || session === void 0 ? void 0 : session.capabilities.supportsBreakpointLocationsRequest)) {
+            return [];
+        }
+        const lineNumbers = Array.from(new Set(breakpoints.map((item) => item.raw.line)));
+        const result = [];
+        await Promise.all(lineNumbers.map(async (lineNumber) => {
+            const positions = await session.breakpointLocations(this.uri, lineNumber);
+            if (positions.length <= 1) {
+                return;
+            }
+            const firstColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
+            const lastColumn = model.getLineLastNonWhitespaceColumn(lineNumber);
+            positions.forEach((p) => {
+                const range = new monaco.Range(p.lineNumber, p.column, p.lineNumber, p.column + 1);
+                if (p.column <= firstColumn || p.column > lastColumn) {
+                    return;
+                }
+                const breakpointAtPosition = this.currentBreakpointDecorations.find(({ breakpoint }) => {
+                    return breakpoint.raw.line === range.startLineNumber && breakpoint.raw.column === range.startColumn;
+                });
+                if (breakpointAtPosition === null || breakpointAtPosition === void 0 ? void 0 : breakpointAtPosition.inlineWidget) {
+                    // Space already occupied, do not render candidate.
+                    return;
+                }
+                result.push({
+                    range,
+                    options: {
+                        description: 'debug-breakpoint-placeholder',
+                        stickiness: monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
+                        beforeContentClassName: breakpointAtPosition ? undefined : 'debug-breakpoint-placeholder',
+                    },
+                    breakpoint: breakpointAtPosition === null || breakpointAtPosition === void 0 ? void 0 : breakpointAtPosition.breakpoint,
+                });
+            });
+        }));
+        return result;
+    }
+    /**
+     * 渲染当前断点装饰器数组
+     * @protected
+     * @returns {monaco.editor.IModelDeltaDecoration[]}
+     * @memberof DebugModel
+     */
+    createCurrentBreakpointDecorations() {
+        const breakpoints = this.breakpointManager.getBreakpoints(this.uri);
+        return breakpoints
+            .filter((breakpoint) => (0, breakpoint_2.isDebugBreakpoint)(breakpoint))
+            .map((breakpoint) => this.createCurrentBreakpointDecoration(breakpoint));
+    }
+    /**
+     * 创建当前断点的装饰器
+     * @protected
+     * @param {DebugBreakpoint} breakpoint
+     * @returns {monaco.editor.IModelDeltaDecoration}
+     * @memberof DebugModel
+     */
+    createCurrentBreakpointDecoration(breakpoint) {
+        const session = this.debugSessionManager.currentSession;
+        const status = breakpoint.status.get(session && session.id || '');
+        const lineNumber = (status && status.line) ? status.line : breakpoint.raw.line;
+        const column = breakpoint.raw.column || 1;
+        const model = this.editor.getModel();
+        const renderInline = column > model.getLineFirstNonWhitespaceColumn(lineNumber);
+        const range = new monaco.Range(lineNumber, column, lineNumber, column + 1);
+        const { className, message } = this.decorator.getDecoration(breakpoint, !!session, this.breakpointManager.breakpointsEnabled);
+        return {
+            range,
+            options: {
+                description: 'debug-breakpoint-placeholder',
+                glyphMarginClassName: className,
+                glyphMarginHoverMessage: message.map((value) => ({ value })),
+                stickiness: options.STICKINESS,
+                beforeContentClassName: renderInline ? 'debug-breakpoint-placeholder' : undefined,
+            },
+        };
+    }
+    updateBreakpointRanges() {
+        this.breakpointRanges.clear();
+        for (const decoration of this.breakpointDecorations) {
+            const range = this.editor.getModel().getDecorationRange(decoration);
+            this.breakpointRanges.set(decoration, range);
+        }
+    }
+    /**
+     * 展示变量Hover面板
+     * @protected
+     * @param {monaco.editor.IEditorMouseEvent} mouseEvent
+     * @returns {void}
+     * @memberof DebugModel
+     */
+    showHover(mouseEvent) {
+        const targetType = mouseEvent.target.type;
+        const stopKey = ide_core_common_1.isOSX ? 'metaKey' : 'ctrlKey';
+        const isAlt = mouseEvent.event.altKey;
+        if (isAlt) {
+            return;
+        }
+        if (targetType === monaco.editor.MouseTargetType.CONTENT_WIDGET && mouseEvent.target.detail === this.debugHoverWidget.getId() && !mouseEvent.event[stopKey]) {
+            return;
+        }
+        if (targetType === monaco.editor.MouseTargetType.CONTENT_TEXT) {
+            this.debugHoverWidget.show({
+                selection: mouseEvent.target.range,
+                immediate: false,
+            });
+        }
+        else {
+            this.debugHoverWidget.hide({ immediate: false });
+        }
+    }
+    /**
+     * 隐藏变量Hover面板
+     * @protected
+     * @param {monaco.editor.IPartialEditorMouseEvent} { event }
+     * @memberof DebugModel
+     */
+    hideHover({ event }) {
+        const rect = this.debugHoverWidget.getDomNode().getBoundingClientRect();
+        if (event.posx < rect.left || event.posx > rect.right || event.posy < rect.top || event.posy > rect.bottom) {
+            this.debugHoverWidget.hide({ immediate: false });
+        }
+    }
+    doToggleBreakpoint(position = this.position) {
+        const breakpoints = this.breakpointManager.getBreakpoints(this.uri, { lineNumber: position.lineNumber });
+        if (breakpoints.length) {
+            for (const breakpoint of breakpoints) {
+                this.breakpointManager.delBreakpoint(breakpoint);
+            }
+        }
+        else {
+            this.breakpointManager.addBreakpoint(breakpoint_2.DebugBreakpoint.create(this.uri, {
+                line: position.lineNumber,
+            }));
+        }
+    }
+    get contributedContextMenu() {
+        const contributedContextMenu = this.menuService.createMenu(next_1.MenuId.DebugBreakpointsContext, this.contextKeyService);
+        return contributedContextMenu;
+    }
+    onContextMenu(event) {
+        if (event.target && event.target.type === monaco.editor.MouseTargetType.GUTTER_GLYPH_MARGIN) {
+            // 设置当前右键选中的断点
+            const breakpoint = this.breakpointManager.getBreakpoint(this.uri, event.target.position.lineNumber);
+            this.breakpointManager.selectedBreakpoint = {
+                breakpoint,
+                model: this,
+            };
+            // 获取右键菜单
+            const menus = this.contributedContextMenu;
+            const menuNodes = (0, next_1.generateMergedCtxMenu)({ menus });
+            this.ctxMenuRenderer.show({
+                anchor: event.event.browserEvent,
+                menuNodes,
+                args: [event.target.position],
+            });
+        }
+    }
+    onMouseDown(event) {
+        if (event.target && event.target.type === monaco.editor.MouseTargetType.GUTTER_GLYPH_MARGIN) {
+            if (!event.event.rightButton) {
+                // 保证在DebugModelManager中准确获取当前焦点的编辑器
+                this.editor.focus();
+                this.toggleBreakpoint(event.target.position);
+            }
+        }
+        this.hintBreakpoint(event);
+    }
+    onMouseMove(event) {
+        this.showHover(event);
+        this.hintBreakpoint(event);
+    }
+    onMouseLeave(event) {
+        this.hideHover(event);
+        this.deltaHintDecorations([]);
+    }
+    getBreakpoints(uri, filter) {
+        return this.breakpointManager.getBreakpoints(uri, filter);
+    }
+    hintBreakpoint(event) {
+        const hintDecorations = this.createHintDecorations(event);
+        this.deltaHintDecorations(hintDecorations);
+    }
+    deltaHintDecorations(hintDecorations) {
+        this.hintDecorations = this.deltaDecorations(this.hintDecorations, hintDecorations);
+    }
+    createHintDecorations(event) {
+        if (event.target
+            && (event.target.type === monaco.editor.MouseTargetType.GUTTER_GLYPH_MARGIN)
+            || event.target.type === monaco.editor.MouseTargetType.GUTTER_LINE_NUMBERS) {
+            const lineNumber = event.target.position.lineNumber;
+            if (!!this.breakpointManager.getBreakpoint(this.uri, lineNumber)) {
+                return [];
+            }
+            return [{
+                    range: new monaco.Range(lineNumber, 1, lineNumber, 1),
+                    options: options.BREAKPOINT_HINT_DECORATION,
+                }];
+        }
+        return [];
+    }
+};
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(debug_editor_1.DebugEditor),
+    (0, tslib_1.__metadata)("design:type", Object)
+], DebugModel.prototype, "editor", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(debug_breakpoint_widget_1.DebugBreakpointWidget),
+    (0, tslib_1.__metadata)("design:type", debug_breakpoint_widget_1.DebugBreakpointWidget)
+], DebugModel.prototype, "breakpointWidget", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(debug_hover_widget_1.DebugHoverWidget),
+    (0, tslib_1.__metadata)("design:type", debug_hover_widget_1.DebugHoverWidget)
+], DebugModel.prototype, "debugHoverWidget", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(debug_session_1.IDebugSessionManager),
+    (0, tslib_1.__metadata)("design:type", debug_session_manager_1.DebugSessionManager)
+], DebugModel.prototype, "debugSessionManager", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(breakpoint_1.BreakpointManager),
+    (0, tslib_1.__metadata)("design:type", breakpoint_1.BreakpointManager)
+], DebugModel.prototype, "breakpointManager", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(next_1.AbstractMenuService),
+    (0, tslib_1.__metadata)("design:type", next_1.AbstractMenuService)
+], DebugModel.prototype, "menuService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.IContextKeyService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], DebugModel.prototype, "contextKeyService", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(next_1.ICtxMenuRenderer),
+    (0, tslib_1.__metadata)("design:type", next_1.ICtxMenuRenderer)
+], DebugModel.prototype, "ctxMenuRenderer", void 0);
+(0, tslib_1.__decorate)([
+    (0, di_1.Autowired)(ide_core_browser_1.IReporterService),
+    (0, tslib_1.__metadata)("design:type", Object)
+], DebugModel.prototype, "reporterService", void 0);
+(0, tslib_1.__decorate)([
+    ide_core_common_1.memoize,
+    (0, tslib_1.__metadata)("design:type", Object),
+    (0, tslib_1.__metadata)("design:paramtypes", [])
+], DebugModel.prototype, "contributedContextMenu", null);
+DebugModel = DebugModel_1 = (0, tslib_1.__decorate)([
+    (0, di_1.Injectable)(),
+    (0, tslib_1.__metadata)("design:paramtypes", [])
+], DebugModel);
+exports.DebugModel = DebugModel;
+class InlineBreakpointWidget extends ide_core_common_1.Disposable {
+    constructor(editor, decorationId, cssClass, breakpoint, breakpointManager) {
+        super();
+        this.editor = editor;
+        this.decorationId = decorationId;
+        this.breakpoint = breakpoint;
+        this.breakpointManager = breakpointManager;
+        this.allowEditorOverflow = false;
+        this.suppressMouseDown = true;
+        this.range = this.editor.getModel().getDecorationRange(decorationId);
+        this.addDispose(this.editor.onDidChangeModelDecorations(() => {
+            const model = this.editor.getModel();
+            const range = model.getDecorationRange(this.decorationId);
+            if (this.range && !this.range.equalsRange(range)) {
+                this.range = range;
+                this.editor.layoutContentWidget(this);
+            }
+        }));
+        this.addDispose(ide_core_common_1.Disposable.create(() => {
+            this.editor.removeContentWidget(this);
+        }));
+        this.create(cssClass);
+        this.editor.addContentWidget(this);
+        this.editor.layoutContentWidget(this);
+    }
+    create(cssClass) {
+        const domNode = document.createElement('div');
+        domNode.className = 'inline-breakpoint-widget';
+        if (cssClass) {
+            domNode.classList.add(...cssClass.split(' '));
+        }
+        this.domNode = domNode;
+        const { EditorOption } = monaco.editor;
+        const updateSize = () => {
+            const lineHeight = this.editor.getOption(EditorOption.lineHeight);
+            domNode.style.height = `${lineHeight}px`;
+            domNode.style.width = `${Math.ceil(0.8 * lineHeight)}px`;
+            domNode.style.marginLeft = `4px`;
+        };
+        updateSize();
+        this.addDispose(new ide_core_browser_1.DomListener(domNode, 'click', async () => {
+            const uri = new ide_core_common_1.URI(this.editor.getModel().uri);
+            if (this.breakpoint) {
+                this.breakpointManager.delBreakpoint(this.breakpoint);
+            }
+            else {
+                this.breakpointManager.addBreakpoint(breakpoint_2.DebugBreakpoint.create(uri, {
+                    line: this.range.startLineNumber,
+                    column: this.range.startColumn,
+                }));
+            }
+        }));
+        this.addDispose(this.editor.onDidChangeConfiguration((c) => {
+            if (c.hasChanged(EditorOption.fontSize) || c.hasChanged(EditorOption.lineHeight)) {
+                updateSize();
+            }
+        }));
+    }
+    getId() {
+        return (0, ide_core_common_1.uuid)();
+    }
+    getDomNode() {
+        return this.domNode;
+    }
+    getPosition() {
+        if (!this.range) {
+            return null;
+        }
+        // Workaround: since the content widget can not be placed before the first column we need to force the left position
+        this.domNode.classList.toggle('line-start', this.range.startColumn === 1);
+        return {
+            position: { lineNumber: this.range.startLineNumber, column: this.range.startColumn - 1 },
+            preference: [monaco.editor.ContentWidgetPositionPreference.EXACT],
+        };
+    }
+}
+(0, tslib_1.__decorate)([
+    ide_core_common_1.memoize,
+    (0, tslib_1.__metadata)("design:type", Function),
+    (0, tslib_1.__metadata)("design:paramtypes", []),
+    (0, tslib_1.__metadata)("design:returntype", void 0)
+], InlineBreakpointWidget.prototype, "getId", null);
+//# sourceMappingURL=debug-model.js.map