@codingame/monaco-vscode-api 4.5.2 → 5.0.0

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

@@ -0,0 +1,354 @@
+import { SHOW_OR_FOCUS_HOVER_ACTION_ID, SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID, SCROLL_UP_HOVER_ACTION_ID, SCROLL_DOWN_HOVER_ACTION_ID, SCROLL_LEFT_HOVER_ACTION_ID, SCROLL_RIGHT_HOVER_ACTION_ID, PAGE_UP_HOVER_ACTION_ID, PAGE_DOWN_HOVER_ACTION_ID, GO_TO_TOP_HOVER_ACTION_ID, GO_TO_BOTTOM_HOVER_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { EditorAction } from '../../../browser/editorExtensions.js';
+import { Range } from '../../../common/core/range.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { GotoDefinitionAtPositionEditorContribution } from '../../gotoSymbol/browser/link/goToDefinitionAtPosition.js';
+import { HoverController } from './hoverController.js';
+import { HoverVerbosityAction } from '../../../common/languages.js';
+import { localizeWithPath, localize2WithPath } from '../../../../nls.js';
+import './hover.css.js';
+const _moduleId = "vs/editor/contrib/hover/browser/hoverActions";
+var HoverFocusBehavior;
+( ((function(HoverFocusBehavior) {
+    HoverFocusBehavior["NoAutoFocus"] = "noAutoFocus";
+    HoverFocusBehavior["FocusIfVisible"] = "focusIfVisible";
+    HoverFocusBehavior["AutoFocusImmediately"] = "autoFocusImmediately";
+})(HoverFocusBehavior || (HoverFocusBehavior = {}))));
+class ShowOrFocusHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: SHOW_OR_FOCUS_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 0, "Show or Focus Hover")),
+            metadata: {
+                description: ( localize2WithPath(
+                    _moduleId,
+                    1,
+                    'Show or focus the editor hover which shows documentation, references, and other content for a symbol at the current cursor position.'
+                )),
+                args: [{
+                        name: 'args',
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                'focus': {
+                                    description: 'Controls if and when the hover should take focus upon being triggered by this action.',
+                                    enum: [HoverFocusBehavior.NoAutoFocus, HoverFocusBehavior.FocusIfVisible, HoverFocusBehavior.AutoFocusImmediately],
+                                    enumDescriptions: [
+                                        ( localizeWithPath(_moduleId, 2, 'The hover will not automatically take focus.')),
+                                        ( localizeWithPath(_moduleId, 3, 'The hover will take focus only if it is already visible.')),
+                                        ( localizeWithPath(_moduleId, 4, 'The hover will automatically take focus when it appears.')),
+                                    ],
+                                    default: HoverFocusBehavior.FocusIfVisible,
+                                }
+                            },
+                        }
+                    }]
+            },
+            alias: 'Show or Focus Hover',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 39 ),
+                weight: 100
+            }
+        });
+    }
+    run(accessor, editor, args) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        const focusArgument = args?.focus;
+        let focusOption = HoverFocusBehavior.FocusIfVisible;
+        if (( (Object.values(HoverFocusBehavior))).includes(focusArgument)) {
+            focusOption = focusArgument;
+        }
+        else if (typeof focusArgument === 'boolean' && focusArgument) {
+            focusOption = HoverFocusBehavior.AutoFocusImmediately;
+        }
+        const showContentHover = (focus) => {
+            const position = editor.getPosition();
+            const range = ( (new Range(position.lineNumber, position.column, position.lineNumber, position.column)));
+            controller.showContentHover(range, 1 , 1 , focus);
+        };
+        const accessibilitySupportEnabled = editor.getOption(2 ) === 2 ;
+        if (controller.isHoverVisible) {
+            if (focusOption !== HoverFocusBehavior.NoAutoFocus) {
+                controller.focus();
+            }
+            else {
+                showContentHover(accessibilitySupportEnabled);
+            }
+        }
+        else {
+            showContentHover(accessibilitySupportEnabled || focusOption === HoverFocusBehavior.AutoFocusImmediately);
+        }
+    }
+}
+class ShowDefinitionPreviewHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 5, "Show Definition Preview Hover")),
+            alias: 'Show Definition Preview Hover',
+            precondition: undefined,
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 6, 'Show the definition preview hover in the editor.')),
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        const position = editor.getPosition();
+        if (!position) {
+            return;
+        }
+        const range = ( (new Range(position.lineNumber, position.column, position.lineNumber, position.column)));
+        const goto = GotoDefinitionAtPositionEditorContribution.get(editor);
+        if (!goto) {
+            return;
+        }
+        const promise = goto.startFindDefinitionFromCursor(position);
+        promise.then(() => {
+            controller.showContentHover(range, 1 , 1 , true);
+        });
+    }
+}
+class ScrollUpHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: SCROLL_UP_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 7, "Scroll Up Hover")),
+            alias: 'Scroll Up Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 16 ,
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 8, 'Scroll up the editor hover.'))
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.scrollUp();
+    }
+}
+class ScrollDownHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: SCROLL_DOWN_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 9, "Scroll Down Hover")),
+            alias: 'Scroll Down Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 18 ,
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 10, 'Scroll down the editor hover.')),
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.scrollDown();
+    }
+}
+class ScrollLeftHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: SCROLL_LEFT_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 11, "Scroll Left Hover")),
+            alias: 'Scroll Left Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 15 ,
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 12, 'Scroll left the editor hover.')),
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.scrollLeft();
+    }
+}
+class ScrollRightHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: SCROLL_RIGHT_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 13, "Scroll Right Hover")),
+            alias: 'Scroll Right Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 17 ,
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 14, 'Scroll right the editor hover.'))
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.scrollRight();
+    }
+}
+class PageUpHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: PAGE_UP_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 15, "Page Up Hover")),
+            alias: 'Page Up Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 11 ,
+                secondary: [512  | 16 ],
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 16, 'Page up the editor hover.')),
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.pageUp();
+    }
+}
+class PageDownHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: PAGE_DOWN_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 17, "Page Down Hover")),
+            alias: 'Page Down Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 12 ,
+                secondary: [512  | 18 ],
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 18, 'Page down the editor hover.')),
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.pageDown();
+    }
+}
+class GoToTopHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: GO_TO_TOP_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 19, "Go To Top Hover")),
+            alias: 'Go To Bottom Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 14 ,
+                secondary: [2048  | 16 ],
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 20, 'Go to the top of the editor hover.')),
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.goToTop();
+    }
+}
+class GoToBottomHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: GO_TO_BOTTOM_HOVER_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 21, "Go To Bottom Hover")),
+            alias: 'Go To Bottom Hover',
+            precondition: EditorContextKeys.hoverFocused,
+            kbOpts: {
+                kbExpr: EditorContextKeys.hoverFocused,
+                primary: 13 ,
+                secondary: [2048  | 18 ],
+                weight: 100
+            },
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 22, 'Go to the bottom of the editor hover.'))
+            },
+        });
+    }
+    run(accessor, editor) {
+        const controller = HoverController.get(editor);
+        if (!controller) {
+            return;
+        }
+        controller.goToBottom();
+    }
+}
+class IncreaseHoverVerbosityLevel extends EditorAction {
+    constructor() {
+        super({
+            id: INCREASE_HOVER_VERBOSITY_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 23, "Increase Hover Verbosity Level")),
+            alias: 'Increase Hover Verbosity Level',
+            precondition: EditorContextKeys.hoverFocused
+        });
+    }
+    run(accessor, editor) {
+        HoverController.get(editor)?.updateFocusedMarkdownHoverVerbosityLevel(HoverVerbosityAction.Increase);
+    }
+}
+class DecreaseHoverVerbosityLevel extends EditorAction {
+    constructor() {
+        super({
+            id: DECREASE_HOVER_VERBOSITY_ACTION_ID,
+            label: ( localizeWithPath(_moduleId, 24, "Decrease Hover Verbosity Level")),
+            alias: 'Decrease Hover Verbosity Level',
+            precondition: EditorContextKeys.hoverFocused
+        });
+    }
+    run(accessor, editor, args) {
+        HoverController.get(editor)?.updateFocusedMarkdownHoverVerbosityLevel(HoverVerbosityAction.Decrease);
+    }
+}
+export { DecreaseHoverVerbosityLevel, GoToBottomHoverAction, GoToTopHoverAction, IncreaseHoverVerbosityLevel, PageDownHoverAction, PageUpHoverAction, ScrollDownHoverAction, ScrollLeftHoverAction, ScrollRightHoverAction, ScrollUpHoverAction, ShowDefinitionPreviewHoverAction, ShowOrFocusHoverAction };

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

@@ -0,0 +1,42 @@
+import { ShowOrFocusHoverAction, ShowDefinitionPreviewHoverAction, ScrollUpHoverAction, ScrollDownHoverAction, ScrollLeftHoverAction, ScrollRightHoverAction, PageUpHoverAction, PageDownHoverAction, GoToTopHoverAction, GoToBottomHoverAction, IncreaseHoverVerbosityLevel, DecreaseHoverVerbosityLevel } from './hoverActions.js';
+import { registerEditorContribution, registerEditorAction } from '../../../browser/editorExtensions.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorHoverBorder } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+import { HoverParticipantRegistry } from './hoverTypes.js';
+import { MarkdownHoverParticipant } from './markdownHoverParticipant.js';
+import { MarkerHoverParticipant } from './markerHoverParticipant.js';
+import { HoverController } from './hoverController.js';
+import './hover.css.js';
+registerEditorContribution(HoverController.ID, HoverController, 2 );
+registerEditorAction(ShowOrFocusHoverAction);
+registerEditorAction(ShowDefinitionPreviewHoverAction);
+registerEditorAction(ScrollUpHoverAction);
+registerEditorAction(ScrollDownHoverAction);
+registerEditorAction(ScrollLeftHoverAction);
+registerEditorAction(ScrollRightHoverAction);
+registerEditorAction(PageUpHoverAction);
+registerEditorAction(PageDownHoverAction);
+registerEditorAction(GoToTopHoverAction);
+registerEditorAction(GoToBottomHoverAction);
+registerEditorAction(IncreaseHoverVerbosityLevel);
+registerEditorAction(DecreaseHoverVerbosityLevel);
+HoverParticipantRegistry.register(MarkdownHoverParticipant);
+HoverParticipantRegistry.register(MarkerHoverParticipant);
+registerThemingParticipant((theme, collector) => {
+    const hoverBorder = theme.getColor(editorHoverBorder);
+    if (hoverBorder) {
+        collector.addRule(`.monaco-editor .monaco-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${( hoverBorder.transparent(0.5))}; }`);
+        collector.addRule(`.monaco-editor .monaco-hover hr { border-top: 1px solid ${( hoverBorder.transparent(0.5))}; }`);
+        collector.addRule(`.monaco-editor .monaco-hover hr { border-bottom: 0px solid ${( hoverBorder.transparent(0.5))}; }`);
+    }
+});