@codingame/monaco-vscode-api 4.5.2 → 5.0.0

package/vscode/src/vs/editor/contrib/hover/browser/hoverController.js

@@ -0,0 +1,320 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { SHOW_OR_FOCUS_HOVER_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { InlineSuggestionHintsContentWidget } from '../../inlineCompletions/browser/inlineCompletionsHintsWidget.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { ContentHoverWidget } from './contentHoverWidget.js';
+import { ContentHoverController } from './contentHoverController.js';
+import './hover.css.js';
+import { MarginHoverWidget } from './marginHoverWidget.js';
+var HoverController_1;
+const _sticky = false;
+let HoverController = class HoverController extends Disposable {
+    static { HoverController_1 = this; }
+    static { this.ID = 'editor.contrib.hover'; }
+    constructor(_editor, _instantiationService, _keybindingService) {
+        super();
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._keybindingService = _keybindingService;
+        this._listenersStore = ( new DisposableStore());
+        this._hoverState = {
+            mouseDown: false,
+            activatedByDecoratorClick: false
+        };
+        this._reactToEditorMouseMoveRunner = this._register(( new RunOnceScheduler(() => this._reactToEditorMouseMove(this._mouseMoveEvent), 0)));
+        this._hookListeners();
+        this._register(this._editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(60 )) {
+                this._unhookListeners();
+                this._hookListeners();
+            }
+        }));
+    }
+    static get(editor) {
+        return editor.getContribution(HoverController_1.ID);
+    }
+    _hookListeners() {
+        const hoverOpts = this._editor.getOption(60 );
+        this._hoverSettings = {
+            enabled: hoverOpts.enabled,
+            sticky: hoverOpts.sticky,
+            hidingDelay: hoverOpts.delay
+        };
+        if (hoverOpts.enabled) {
+            this._listenersStore.add(this._editor.onMouseDown((e) => this._onEditorMouseDown(e)));
+            this._listenersStore.add(this._editor.onMouseUp(() => this._onEditorMouseUp()));
+            this._listenersStore.add(this._editor.onMouseMove((e) => this._onEditorMouseMove(e)));
+            this._listenersStore.add(this._editor.onKeyDown((e) => this._onKeyDown(e)));
+        }
+        else {
+            this._listenersStore.add(this._editor.onMouseMove((e) => this._onEditorMouseMove(e)));
+            this._listenersStore.add(this._editor.onKeyDown((e) => this._onKeyDown(e)));
+        }
+        this._listenersStore.add(this._editor.onMouseLeave((e) => this._onEditorMouseLeave(e)));
+        this._listenersStore.add(this._editor.onDidChangeModel(() => {
+            this._cancelScheduler();
+            this._hideWidgets();
+        }));
+        this._listenersStore.add(this._editor.onDidChangeModelContent(() => this._cancelScheduler()));
+        this._listenersStore.add(this._editor.onDidScrollChange((e) => this._onEditorScrollChanged(e)));
+    }
+    _unhookListeners() {
+        this._listenersStore.clear();
+    }
+    _cancelScheduler() {
+        this._mouseMoveEvent = undefined;
+        this._reactToEditorMouseMoveRunner.cancel();
+    }
+    _onEditorScrollChanged(e) {
+        if (e.scrollTopChanged || e.scrollLeftChanged) {
+            this._hideWidgets();
+        }
+    }
+    _onEditorMouseDown(mouseEvent) {
+        this._hoverState.mouseDown = true;
+        const shouldNotHideCurrentHoverWidget = this._shouldNotHideCurrentHoverWidget(mouseEvent);
+        if (shouldNotHideCurrentHoverWidget) {
+            return;
+        }
+        this._hideWidgets();
+    }
+    _shouldNotHideCurrentHoverWidget(mouseEvent) {
+        if (this._isMouseOnContentHoverWidget(mouseEvent)
+            || this._isMouseOnMarginHoverWidget(mouseEvent)
+            || this._isContentWidgetResizing()) {
+            return true;
+        }
+        return false;
+    }
+    _isMouseOnMarginHoverWidget(mouseEvent) {
+        const target = mouseEvent.target;
+        if (!target) {
+            return false;
+        }
+        return target.type === 12  && target.detail === MarginHoverWidget.ID;
+    }
+    _isMouseOnContentHoverWidget(mouseEvent) {
+        const target = mouseEvent.target;
+        if (!target) {
+            return false;
+        }
+        return target.type === 9  && target.detail === ContentHoverWidget.ID;
+    }
+    _onEditorMouseUp() {
+        this._hoverState.mouseDown = false;
+    }
+    _onEditorMouseLeave(mouseEvent) {
+        this._cancelScheduler();
+        const shouldNotHideCurrentHoverWidget = this._shouldNotHideCurrentHoverWidget(mouseEvent);
+        if (shouldNotHideCurrentHoverWidget) {
+            return;
+        }
+        this._hideWidgets();
+    }
+    _shouldNotRecomputeCurrentHoverWidget(mouseEvent) {
+        const isHoverSticky = this._hoverSettings.sticky;
+        const isMouseOnStickyMarginHoverWidget = (mouseEvent, isHoverSticky) => {
+            const isMouseOnMarginHoverWidget = this._isMouseOnMarginHoverWidget(mouseEvent);
+            return isHoverSticky && isMouseOnMarginHoverWidget;
+        };
+        const isMouseOnStickyContentHoverWidget = (mouseEvent, isHoverSticky) => {
+            const isMouseOnContentHoverWidget = this._isMouseOnContentHoverWidget(mouseEvent);
+            return isHoverSticky && isMouseOnContentHoverWidget;
+        };
+        const isMouseOnColorPicker = (mouseEvent) => {
+            const isMouseOnContentHoverWidget = this._isMouseOnContentHoverWidget(mouseEvent);
+            const isColorPickerVisible = this._contentWidget?.isColorPickerVisible;
+            return isMouseOnContentHoverWidget && isColorPickerVisible;
+        };
+        const isTextSelectedWithinContentHoverWidget = (mouseEvent, sticky) => {
+            return sticky
+                && this._contentWidget?.containsNode(mouseEvent.event.browserEvent.view?.document.activeElement)
+                && !mouseEvent.event.browserEvent.view?.getSelection()?.isCollapsed;
+        };
+        if (isMouseOnStickyMarginHoverWidget(mouseEvent, isHoverSticky)
+            || isMouseOnStickyContentHoverWidget(mouseEvent, isHoverSticky)
+            || isMouseOnColorPicker(mouseEvent)
+            || isTextSelectedWithinContentHoverWidget(mouseEvent, isHoverSticky)) {
+            return true;
+        }
+        return false;
+    }
+    _onEditorMouseMove(mouseEvent) {
+        this._mouseMoveEvent = mouseEvent;
+        if (this._contentWidget?.isFocused || this._contentWidget?.isResizing) {
+            return;
+        }
+        const sticky = this._hoverSettings.sticky;
+        if (sticky && this._contentWidget?.isVisibleFromKeyboard) {
+            return;
+        }
+        const shouldNotRecomputeCurrentHoverWidget = this._shouldNotRecomputeCurrentHoverWidget(mouseEvent);
+        if (shouldNotRecomputeCurrentHoverWidget) {
+            this._reactToEditorMouseMoveRunner.cancel();
+            return;
+        }
+        const hidingDelay = this._hoverSettings.hidingDelay;
+        const isContentHoverWidgetVisible = this._contentWidget?.isVisible;
+        const shouldRescheduleHoverComputation = isContentHoverWidgetVisible && sticky && hidingDelay > 0;
+        if (shouldRescheduleHoverComputation) {
+            if (!this._reactToEditorMouseMoveRunner.isScheduled()) {
+                this._reactToEditorMouseMoveRunner.schedule(hidingDelay);
+            }
+            return;
+        }
+        this._reactToEditorMouseMove(mouseEvent);
+    }
+    _reactToEditorMouseMove(mouseEvent) {
+        if (!mouseEvent) {
+            return;
+        }
+        const target = mouseEvent.target;
+        const mouseOnDecorator = target.element?.classList.contains('colorpicker-color-decoration');
+        const decoratorActivatedOn = this._editor.getOption(148 );
+        const enabled = this._hoverSettings.enabled;
+        const activatedByDecoratorClick = this._hoverState.activatedByDecoratorClick;
+        if ((mouseOnDecorator && ((decoratorActivatedOn === 'click' && !activatedByDecoratorClick) ||
+            (decoratorActivatedOn === 'hover' && !enabled && !_sticky) ||
+            (decoratorActivatedOn === 'clickAndHover' && !enabled && !activatedByDecoratorClick))) || (!mouseOnDecorator && !enabled && !activatedByDecoratorClick)) {
+            this._hideWidgets();
+            return;
+        }
+        const contentHoverShowsOrWillShow = this._tryShowHoverWidget(mouseEvent, 0 );
+        if (contentHoverShowsOrWillShow) {
+            return;
+        }
+        const glyphWidgetShowsOrWillShow = this._tryShowHoverWidget(mouseEvent, 1 );
+        if (glyphWidgetShowsOrWillShow) {
+            return;
+        }
+        this._hideWidgets();
+    }
+    _tryShowHoverWidget(mouseEvent, hoverWidgetType) {
+        const contentWidget = this._getOrCreateContentWidget();
+        const glyphWidget = this._getOrCreateGlyphWidget();
+        let currentWidget;
+        let otherWidget;
+        switch (hoverWidgetType) {
+            case 0 :
+                currentWidget = contentWidget;
+                otherWidget = glyphWidget;
+                break;
+            case 1 :
+                currentWidget = glyphWidget;
+                otherWidget = contentWidget;
+                break;
+            default:
+                throw ( new Error(`HoverWidgetType ${hoverWidgetType} is unrecognized`));
+        }
+        const showsOrWillShow = currentWidget.showsOrWillShow(mouseEvent);
+        if (showsOrWillShow) {
+            otherWidget.hide();
+        }
+        return showsOrWillShow;
+    }
+    _onKeyDown(e) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const resolvedKeyboardEvent = this._keybindingService.softDispatch(e, this._editor.getDomNode());
+        const shouldKeepHoverVisible = (resolvedKeyboardEvent.kind === 1  ||
+            (resolvedKeyboardEvent.kind === 2
+                && (resolvedKeyboardEvent.commandId === SHOW_OR_FOCUS_HOVER_ACTION_ID
+                    || resolvedKeyboardEvent.commandId === INCREASE_HOVER_VERBOSITY_ACTION_ID
+                    || resolvedKeyboardEvent.commandId === DECREASE_HOVER_VERBOSITY_ACTION_ID)
+                && this._contentWidget?.isVisible));
+        if (e.keyCode === 5
+            || e.keyCode === 6
+            || e.keyCode === 57
+            || e.keyCode === 4
+            || shouldKeepHoverVisible) {
+            return;
+        }
+        this._hideWidgets();
+    }
+    _hideWidgets() {
+        if ((this._hoverState.mouseDown
+            && this._contentWidget?.isColorPickerVisible) || InlineSuggestionHintsContentWidget.dropDownVisible) {
+            return;
+        }
+        this._hoverState.activatedByDecoratorClick = false;
+        this._glyphWidget?.hide();
+        this._contentWidget?.hide();
+    }
+    _getOrCreateContentWidget() {
+        if (!this._contentWidget) {
+            this._contentWidget = this._instantiationService.createInstance(ContentHoverController, this._editor);
+        }
+        return this._contentWidget;
+    }
+    _getOrCreateGlyphWidget() {
+        if (!this._glyphWidget) {
+            this._glyphWidget = this._instantiationService.createInstance(MarginHoverWidget, this._editor);
+        }
+        return this._glyphWidget;
+    }
+    hideContentHover() {
+        this._hideWidgets();
+    }
+    showContentHover(range, mode, source, focus, activatedByColorDecoratorClick = false) {
+        this._hoverState.activatedByDecoratorClick = activatedByColorDecoratorClick;
+        this._getOrCreateContentWidget().startShowingAtRange(range, mode, source, focus);
+    }
+    _isContentWidgetResizing() {
+        return this._contentWidget?.widget.isResizing || false;
+    }
+    updateFocusedMarkdownHoverVerbosityLevel(action) {
+        this._getOrCreateContentWidget().updateFocusedMarkdownHoverVerbosityLevel(action);
+    }
+    focus() {
+        this._contentWidget?.focus();
+    }
+    scrollUp() {
+        this._contentWidget?.scrollUp();
+    }
+    scrollDown() {
+        this._contentWidget?.scrollDown();
+    }
+    scrollLeft() {
+        this._contentWidget?.scrollLeft();
+    }
+    scrollRight() {
+        this._contentWidget?.scrollRight();
+    }
+    pageUp() {
+        this._contentWidget?.pageUp();
+    }
+    pageDown() {
+        this._contentWidget?.pageDown();
+    }
+    goToTop() {
+        this._contentWidget?.goToTop();
+    }
+    goToBottom() {
+        this._contentWidget?.goToBottom();
+    }
+    getWidgetContent() {
+        return this._contentWidget?.getWidgetContent();
+    }
+    get isColorPickerVisible() {
+        return this._contentWidget?.isColorPickerVisible;
+    }
+    get isHoverVisible() {
+        return this._contentWidget?.isVisible;
+    }
+    dispose() {
+        super.dispose();
+        this._unhookListeners();
+        this._listenersStore.dispose();
+        this._glyphWidget?.dispose();
+        this._contentWidget?.dispose();
+    }
+};
+HoverController = HoverController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService))
+], HoverController));
+export { HoverController };

package/vscode/src/vs/editor/contrib/hover/browser/marginHoverComputer.js

@@ -0,0 +1,48 @@
+import { asArray } from '../../../../base/common/arrays.js';
+import { isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
+import { GlyphMarginLane } from '../../../common/model.js';
+class MarginHoverComputer {
+    get lineNumber() {
+        return this._lineNumber;
+    }
+    set lineNumber(value) {
+        this._lineNumber = value;
+    }
+    get lane() {
+        return this._laneOrLine;
+    }
+    set lane(value) {
+        this._laneOrLine = value;
+    }
+    constructor(_editor) {
+        this._editor = _editor;
+        this._lineNumber = -1;
+        this._laneOrLine = GlyphMarginLane.Center;
+    }
+    computeSync() {
+        const toHoverMessage = (contents) => {
+            return {
+                value: contents
+            };
+        };
+        const lineDecorations = this._editor.getLineDecorations(this._lineNumber);
+        const result = [];
+        const isLineHover = this._laneOrLine === 'lineNo';
+        if (!lineDecorations) {
+            return result;
+        }
+        for (const d of lineDecorations) {
+            const lane = d.options.glyphMargin?.position ?? GlyphMarginLane.Center;
+            if (!isLineHover && lane !== this._laneOrLine) {
+                continue;
+            }
+            const hoverMessage = isLineHover ? d.options.lineNumberHoverMessage : d.options.glyphMarginHoverMessage;
+            if (!hoverMessage || isEmptyMarkdownString(hoverMessage)) {
+                continue;
+            }
+            result.push(...( asArray(hoverMessage).map(toHoverMessage)));
+        }
+        return result;
+    }
+}
+export { MarginHoverComputer };

package/vscode/src/vs/editor/contrib/hover/browser/{marginHover.js → marginHoverWidget.js}

@@ -1,11 +1,9 @@
 import { append, $ as $$1 } from '../../../../base/browser/dom.js';
-import { asArray } from '../../../../base/common/arrays.js';
-import { isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
 import { HoverOperation } from './hoverOperation.js';
 import { HoverWidget } from '../../../../base/browser/ui/hover/hoverWidget.js';
-import { GlyphMarginLane } from '../../../common/model.js';
+import { MarginHoverComputer } from './marginHoverComputer.js';
 const $ = $$1;
 class MarginHoverWidget extends Disposable {
     static { this.ID = 'editor.contrib.modesGlyphHoverWidget'; }
@@ -54,7 +52,19 @@ class MarginHoverWidget extends Disposable {
             this._hoverOperation.start(0 );
         }
     }
-    startShowingAt(lineNumber, laneOrLine) {
+    showsOrWillShow(mouseEvent) {
+        const target = mouseEvent.target;
+        if (target.type === 2  && target.detail.glyphMarginLane) {
+            this._startShowingAt(target.position.lineNumber, target.detail.glyphMarginLane);
+            return true;
+        }
+        if (target.type === 3 ) {
+            this._startShowingAt(target.position.lineNumber, 'lineNo');
+            return true;
+        }
+        return false;
+    }
+    _startShowingAt(lineNumber, laneOrLine) {
         if (this._computer.lineNumber === lineNumber && this._computer.lane === laneOrLine) {
             return;
         }
@@ -116,48 +126,4 @@ class MarginHoverWidget extends Disposable {
         this._hover.containerDomNode.style.top = `${Math.max(Math.round(top), 0)}px`;
     }
 }
-class MarginHoverComputer {
-    get lineNumber() {
-        return this._lineNumber;
-    }
-    set lineNumber(value) {
-        this._lineNumber = value;
-    }
-    get lane() {
-        return this._laneOrLine;
-    }
-    set lane(value) {
-        this._laneOrLine = value;
-    }
-    constructor(_editor) {
-        this._editor = _editor;
-        this._lineNumber = -1;
-        this._laneOrLine = GlyphMarginLane.Center;
-    }
-    computeSync() {
-        const toHoverMessage = (contents) => {
-            return {
-                value: contents
-            };
-        };
-        const lineDecorations = this._editor.getLineDecorations(this._lineNumber);
-        const result = [];
-        const isLineHover = this._laneOrLine === 'lineNo';
-        if (!lineDecorations) {
-            return result;
-        }
-        for (const d of lineDecorations) {
-            const lane = d.options.glyphMargin?.position ?? GlyphMarginLane.Center;
-            if (!isLineHover && lane !== this._laneOrLine) {
-                continue;
-            }
-            const hoverMessage = isLineHover ? d.options.lineNumberHoverMessage : d.options.glyphMarginHoverMessage;
-            if (!hoverMessage || isEmptyMarkdownString(hoverMessage)) {
-                continue;
-            }
-            result.push(...( asArray(hoverMessage).map(toHoverMessage)));
-        }
-        return result;
-    }
-}
 export { MarginHoverWidget };