@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -0,0 +1,355 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Dimension, append, trackFocus, getClientArea, getDomNodePagePosition, getTotalHeight, getTotalWidth } from '../../../../base/browser/dom.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { ResizableContentWidget } from './resizableContentWidget.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { HoverWidget, getHoverAccessibleViewHint } from '../../../../base/browser/ui/hover/hoverWidget.js';
+var ContentHoverWidget_1;
+const HORIZONTAL_SCROLLING_BY = 30;
+const CONTAINER_HEIGHT_PADDING = 6;
+let ContentHoverWidget = class ContentHoverWidget extends ResizableContentWidget {
+    static { ContentHoverWidget_1 = this; }
+    static { this.ID = 'editor.contrib.resizableContentHoverWidget'; }
+    static { this._lastDimensions = new Dimension(0, 0); }
+    get isColorPickerVisible() {
+        return Boolean(this._visibleData?.colorPicker);
+    }
+    get isVisibleFromKeyboard() {
+        return (this._visibleData?.source === 1) ;
+    }
+    get isVisible() {
+        return this._hoverVisibleKey.get() ?? false;
+    }
+    get isFocused() {
+        return this._hoverFocusedKey.get() ?? false;
+    }
+    constructor(editor, contextKeyService, _configurationService, _accessibilityService, _keybindingService) {
+        const minimumHeight = editor.getOption(67 ) + 8;
+        const minimumWidth = 150;
+        const minimumSize = new Dimension(minimumWidth, minimumHeight);
+        super(editor, minimumSize);
+        this._configurationService = _configurationService;
+        this._accessibilityService = _accessibilityService;
+        this._keybindingService = _keybindingService;
+        this._hover = this._register(( new HoverWidget()));
+        this._minimumSize = minimumSize;
+        this._hoverVisibleKey = EditorContextKeys.hoverVisible.bindTo(contextKeyService);
+        this._hoverFocusedKey = EditorContextKeys.hoverFocused.bindTo(contextKeyService);
+        append(this._resizableNode.domNode, this._hover.containerDomNode);
+        this._resizableNode.domNode.style.zIndex = '50';
+        this._register(this._editor.onDidLayoutChange(() => {
+            if (this.isVisible) {
+                this._updateMaxDimensions();
+            }
+        }));
+        this._register(this._editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(50 )) {
+                this._updateFont();
+            }
+        }));
+        const focusTracker = this._register(trackFocus(this._resizableNode.domNode));
+        this._register(focusTracker.onDidFocus(() => {
+            this._hoverFocusedKey.set(true);
+        }));
+        this._register(focusTracker.onDidBlur(() => {
+            this._hoverFocusedKey.set(false);
+        }));
+        this._setHoverData(undefined);
+        this._editor.addContentWidget(this);
+    }
+    dispose() {
+        super.dispose();
+        this._visibleData?.disposables.dispose();
+        this._editor.removeContentWidget(this);
+    }
+    getId() {
+        return ContentHoverWidget_1.ID;
+    }
+    static _applyDimensions(container, width, height) {
+        const transformedWidth = typeof width === 'number' ? `${width}px` : width;
+        const transformedHeight = typeof height === 'number' ? `${height}px` : height;
+        container.style.width = transformedWidth;
+        container.style.height = transformedHeight;
+    }
+    _setContentsDomNodeDimensions(width, height) {
+        const contentsDomNode = this._hover.contentsDomNode;
+        return ContentHoverWidget_1._applyDimensions(contentsDomNode, width, height);
+    }
+    _setContainerDomNodeDimensions(width, height) {
+        const containerDomNode = this._hover.containerDomNode;
+        return ContentHoverWidget_1._applyDimensions(containerDomNode, width, height);
+    }
+    _setHoverWidgetDimensions(width, height) {
+        this._setContentsDomNodeDimensions(width, height);
+        this._setContainerDomNodeDimensions(width, height);
+        this._layoutContentWidget();
+    }
+    static _applyMaxDimensions(container, width, height) {
+        const transformedWidth = typeof width === 'number' ? `${width}px` : width;
+        const transformedHeight = typeof height === 'number' ? `${height}px` : height;
+        container.style.maxWidth = transformedWidth;
+        container.style.maxHeight = transformedHeight;
+    }
+    _setHoverWidgetMaxDimensions(width, height) {
+        ContentHoverWidget_1._applyMaxDimensions(this._hover.contentsDomNode, width, height);
+        ContentHoverWidget_1._applyMaxDimensions(this._hover.containerDomNode, width, height);
+        this._hover.containerDomNode.style.setProperty('--vscode-hover-maxWidth', typeof width === 'number' ? `${width}px` : width);
+        this._layoutContentWidget();
+    }
+    _setAdjustedHoverWidgetDimensions(size) {
+        this._setHoverWidgetMaxDimensions('none', 'none');
+        const width = size.width;
+        const height = size.height;
+        this._setHoverWidgetDimensions(width, height);
+    }
+    _updateResizableNodeMaxDimensions() {
+        const maxRenderingWidth = this._findMaximumRenderingWidth() ?? Infinity;
+        const maxRenderingHeight = this._findMaximumRenderingHeight() ?? Infinity;
+        this._resizableNode.maxSize = new Dimension(maxRenderingWidth, maxRenderingHeight);
+        this._setHoverWidgetMaxDimensions(maxRenderingWidth, maxRenderingHeight);
+    }
+    _resize(size) {
+        ContentHoverWidget_1._lastDimensions = new Dimension(size.width, size.height);
+        this._setAdjustedHoverWidgetDimensions(size);
+        this._resizableNode.layout(size.height, size.width);
+        this._updateResizableNodeMaxDimensions();
+        this._hover.scrollbar.scanDomNode();
+        this._editor.layoutContentWidget(this);
+        this._visibleData?.colorPicker?.layout();
+    }
+    _findAvailableSpaceVertically() {
+        const position = this._visibleData?.showAtPosition;
+        if (!position) {
+            return;
+        }
+        return this._positionPreference === 1  ?
+            this._availableVerticalSpaceAbove(position)
+            : this._availableVerticalSpaceBelow(position);
+    }
+    _findMaximumRenderingHeight() {
+        const availableSpace = this._findAvailableSpaceVertically();
+        if (!availableSpace) {
+            return;
+        }
+        let maximumHeight = CONTAINER_HEIGHT_PADDING;
+        Array.from(this._hover.contentsDomNode.children).forEach((hoverPart) => {
+            maximumHeight += hoverPart.clientHeight;
+        });
+        return Math.min(availableSpace, maximumHeight);
+    }
+    _isHoverTextOverflowing() {
+        this._hover.containerDomNode.style.setProperty('--vscode-hover-whiteSpace', 'nowrap');
+        this._hover.containerDomNode.style.setProperty('--vscode-hover-sourceWhiteSpace', 'nowrap');
+        const overflowing = ( Array.from(this._hover.contentsDomNode.children).some((hoverElement) => {
+            return hoverElement.scrollWidth > hoverElement.clientWidth;
+        }));
+        this._hover.containerDomNode.style.removeProperty('--vscode-hover-whiteSpace');
+        this._hover.containerDomNode.style.removeProperty('--vscode-hover-sourceWhiteSpace');
+        return overflowing;
+    }
+    _findMaximumRenderingWidth() {
+        if (!this._editor || !this._editor.hasModel()) {
+            return;
+        }
+        const overflowing = this._isHoverTextOverflowing();
+        const initialWidth = ((typeof this._contentWidth === 'undefined' ? 0 : this._contentWidth - 2)
+        );
+        if (overflowing || this._hover.containerDomNode.clientWidth < initialWidth) {
+            const bodyBoxWidth = getClientArea(this._hover.containerDomNode.ownerDocument.body).width;
+            const horizontalPadding = 14;
+            return bodyBoxWidth - horizontalPadding;
+        }
+        else {
+            return this._hover.containerDomNode.clientWidth + 2;
+        }
+    }
+    isMouseGettingCloser(posx, posy) {
+        if (!this._visibleData) {
+            return false;
+        }
+        if (typeof this._visibleData.initialMousePosX === 'undefined'
+            || typeof this._visibleData.initialMousePosY === 'undefined') {
+            this._visibleData.initialMousePosX = posx;
+            this._visibleData.initialMousePosY = posy;
+            return false;
+        }
+        const widgetRect = getDomNodePagePosition(this.getDomNode());
+        if (typeof this._visibleData.closestMouseDistance === 'undefined') {
+            this._visibleData.closestMouseDistance = computeDistanceFromPointToRectangle(this._visibleData.initialMousePosX, this._visibleData.initialMousePosY, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
+        }
+        const distance = computeDistanceFromPointToRectangle(posx, posy, widgetRect.left, widgetRect.top, widgetRect.width, widgetRect.height);
+        if (distance > this._visibleData.closestMouseDistance + 4 ) {
+            return false;
+        }
+        this._visibleData.closestMouseDistance = Math.min(this._visibleData.closestMouseDistance, distance);
+        return true;
+    }
+    _setHoverData(hoverData) {
+        this._visibleData?.disposables.dispose();
+        this._visibleData = hoverData;
+        this._hoverVisibleKey.set(!!hoverData);
+        this._hover.containerDomNode.classList.toggle('hidden', !hoverData);
+    }
+    _updateFont() {
+        const { fontSize, lineHeight } = this._editor.getOption(50 );
+        const contentsDomNode = this._hover.contentsDomNode;
+        contentsDomNode.style.fontSize = `${fontSize}px`;
+        contentsDomNode.style.lineHeight = `${lineHeight / fontSize}`;
+        const codeClasses = Array.prototype.slice.call(this._hover.contentsDomNode.getElementsByClassName('code'));
+        codeClasses.forEach(node => this._editor.applyFontInfo(node));
+    }
+    _updateContent(node) {
+        const contentsDomNode = this._hover.contentsDomNode;
+        contentsDomNode.style.paddingBottom = '';
+        contentsDomNode.textContent = '';
+        contentsDomNode.appendChild(node);
+    }
+    _layoutContentWidget() {
+        this._editor.layoutContentWidget(this);
+        this._hover.onContentsChanged();
+    }
+    _updateMaxDimensions() {
+        const height = Math.max(this._editor.getLayoutInfo().height / 4, 250, ContentHoverWidget_1._lastDimensions.height);
+        const width = Math.max(this._editor.getLayoutInfo().width * 0.66, 500, ContentHoverWidget_1._lastDimensions.width);
+        this._setHoverWidgetMaxDimensions(width, height);
+    }
+    _render(node, hoverData) {
+        this._setHoverData(hoverData);
+        this._updateFont();
+        this._updateContent(node);
+        this._updateMaxDimensions();
+        this.onContentsChanged();
+        this._editor.render();
+    }
+    getPosition() {
+        if (!this._visibleData) {
+            return null;
+        }
+        return {
+            position: this._visibleData.showAtPosition,
+            secondaryPosition: this._visibleData.showAtSecondaryPosition,
+            positionAffinity: this._visibleData.isBeforeContent ? 3  : undefined,
+            preference: [this._positionPreference ?? 1 ]
+        };
+    }
+    showAt(node, hoverData) {
+        if (!this._editor || !this._editor.hasModel()) {
+            return;
+        }
+        this._render(node, hoverData);
+        const widgetHeight = getTotalHeight(this._hover.containerDomNode);
+        const widgetPosition = hoverData.showAtPosition;
+        this._positionPreference = this._findPositionPreference(widgetHeight, widgetPosition) ?? 1 ;
+        this.onContentsChanged();
+        if (hoverData.stoleFocus) {
+            this._hover.containerDomNode.focus();
+        }
+        hoverData.colorPicker?.layout();
+        const hoverFocused = this._hover.containerDomNode.ownerDocument.activeElement === this._hover.containerDomNode;
+        const accessibleViewHint = hoverFocused && getHoverAccessibleViewHint(this._configurationService.getValue('accessibility.verbosity.hover') === true && this._accessibilityService.isScreenReaderOptimized(), this._keybindingService.lookupKeybinding('editor.action.accessibleView')?.getAriaLabel() ?? '');
+        if (accessibleViewHint) {
+            this._hover.contentsDomNode.ariaLabel = this._hover.contentsDomNode.textContent + ', ' + accessibleViewHint;
+        }
+    }
+    hide() {
+        if (!this._visibleData) {
+            return;
+        }
+        const stoleFocus = this._visibleData.stoleFocus || this._hoverFocusedKey.get();
+        this._setHoverData(undefined);
+        this._resizableNode.maxSize = new Dimension(Infinity, Infinity);
+        this._resizableNode.clearSashHoverState();
+        this._hoverFocusedKey.set(false);
+        this._editor.layoutContentWidget(this);
+        if (stoleFocus) {
+            this._editor.focus();
+        }
+    }
+    _removeConstraintsRenderNormally() {
+        const layoutInfo = this._editor.getLayoutInfo();
+        this._resizableNode.layout(layoutInfo.height, layoutInfo.width);
+        this._setHoverWidgetDimensions('auto', 'auto');
+    }
+    setMinimumDimensions(dimensions) {
+        this._minimumSize = new Dimension(Math.max(this._minimumSize.width, dimensions.width), Math.max(this._minimumSize.height, dimensions.height));
+        this._updateMinimumWidth();
+    }
+    _updateMinimumWidth() {
+        const width = (typeof this._contentWidth === 'undefined'
+            ? this._minimumSize.width
+            : Math.min(this._contentWidth, this._minimumSize.width));
+        this._resizableNode.minSize = new Dimension(width, this._minimumSize.height);
+    }
+    onContentsChanged() {
+        this._removeConstraintsRenderNormally();
+        const containerDomNode = this._hover.containerDomNode;
+        let height = getTotalHeight(containerDomNode);
+        let width = getTotalWidth(containerDomNode);
+        this._resizableNode.layout(height, width);
+        this._setHoverWidgetDimensions(width, height);
+        height = getTotalHeight(containerDomNode);
+        width = getTotalWidth(containerDomNode);
+        this._contentWidth = width;
+        this._updateMinimumWidth();
+        this._resizableNode.layout(height, width);
+        if (this._visibleData?.showAtPosition) {
+            const widgetHeight = getTotalHeight(this._hover.containerDomNode);
+            this._positionPreference = this._findPositionPreference(widgetHeight, this._visibleData.showAtPosition);
+        }
+        this._layoutContentWidget();
+    }
+    focus() {
+        this._hover.containerDomNode.focus();
+    }
+    scrollUp() {
+        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
+        const fontInfo = this._editor.getOption(50 );
+        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop - fontInfo.lineHeight });
+    }
+    scrollDown() {
+        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
+        const fontInfo = this._editor.getOption(50 );
+        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop + fontInfo.lineHeight });
+    }
+    scrollLeft() {
+        const scrollLeft = this._hover.scrollbar.getScrollPosition().scrollLeft;
+        this._hover.scrollbar.setScrollPosition({ scrollLeft: scrollLeft - HORIZONTAL_SCROLLING_BY });
+    }
+    scrollRight() {
+        const scrollLeft = this._hover.scrollbar.getScrollPosition().scrollLeft;
+        this._hover.scrollbar.setScrollPosition({ scrollLeft: scrollLeft + HORIZONTAL_SCROLLING_BY });
+    }
+    pageUp() {
+        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
+        const scrollHeight = this._hover.scrollbar.getScrollDimensions().height;
+        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop - scrollHeight });
+    }
+    pageDown() {
+        const scrollTop = this._hover.scrollbar.getScrollPosition().scrollTop;
+        const scrollHeight = this._hover.scrollbar.getScrollDimensions().height;
+        this._hover.scrollbar.setScrollPosition({ scrollTop: scrollTop + scrollHeight });
+    }
+    goToTop() {
+        this._hover.scrollbar.setScrollPosition({ scrollTop: 0 });
+    }
+    goToBottom() {
+        this._hover.scrollbar.setScrollPosition({ scrollTop: this._hover.scrollbar.getScrollDimensions().scrollHeight });
+    }
+};
+ContentHoverWidget = ContentHoverWidget_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IAccessibilityService)),
+    ( __param(4, IKeybindingService))
+], ContentHoverWidget));
+function computeDistanceFromPointToRectangle(pointX, pointY, left, top, width, height) {
+    const x = (left + width / 2);
+    const y = (top + height / 2);
+    const dx = Math.max(Math.abs(pointX - x) - width / 2, 0);
+    const dy = Math.max(Math.abs(pointY - y) - height / 2, 0);
+    return Math.sqrt(dx * dx + dy * dy);
+}
+export { ContentHoverWidget };

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

@@ -11,34 +11,31 @@ class HoverProviderResult {
     }
 }
 async function executeProvider(provider, ordinal, model, position, token) {
-    try {
-        const result = await Promise.resolve(provider.provideHover(model, position, token));
-        if (result && isValid(result)) {
-            return ( new HoverProviderResult(provider, result, ordinal));
-        }
+    const result = await Promise
+        .resolve(provider.provideHover(model, position, token))
+        .catch(onUnexpectedExternalError);
+    if (!result || !isValid(result)) {
+        return undefined;
     }
-    catch (err) {
-        onUnexpectedExternalError(err);
-    }
-    return undefined;
+    return ( new HoverProviderResult(provider, result, ordinal));
 }
-function getHover(registry, model, position, token) {
+function getHoverProviderResultsAsAsyncIterable(registry, model, position, token) {
     const providers = registry.ordered(model);
     const promises = ( providers.map(
         (provider, index) => executeProvider(provider, index, model, position, token)
     ));
     return AsyncIterableObject.fromPromises(promises).coalesce();
 }
-function getHoverPromise(registry, model, position, token) {
-    return ( getHover(registry, model, position, token).map(item => item.hover)).toPromise();
+function getHoversPromise(registry, model, position, token) {
+    return ( getHoverProviderResultsAsAsyncIterable(registry, model, position, token).map(item => item.hover)).toPromise();
 }
 registerModelAndPositionCommand('_executeHoverProvider', (accessor, model, position) => {
     const languageFeaturesService = accessor.get(ILanguageFeaturesService);
-    return getHoverPromise(languageFeaturesService.hoverProvider, model, position, CancellationToken.None);
+    return getHoversPromise(languageFeaturesService.hoverProvider, model, position, CancellationToken.None);
 });
 function isValid(result) {
     const hasRange = (typeof result.range !== 'undefined');
     const hasHtmlContent = typeof result.contents !== 'undefined' && result.contents && result.contents.length > 0;
     return hasRange && hasHtmlContent;
 }
-export { HoverProviderResult, getHover, getHoverPromise };
+export { HoverProviderResult, getHoverProviderResultsAsAsyncIterable, getHoversPromise };

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

@@ -1,4 +1,4 @@
 import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".monaco-editor .hoverHighlight{background-color:var(--vscode-editor-hoverHighlightBackground)}.monaco-editor .monaco-hover{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;color:var(--vscode-editorHoverWidget-foreground)}.monaco-editor .monaco-hover a{color:var(--vscode-textLink-foreground)}.monaco-editor .monaco-hover a:hover{color:var(--vscode-textLink-activeForeground)}.monaco-editor .monaco-hover .hover-row .actions{background-color:var(--vscode-editorHoverWidget-statusBarBackground)}.monaco-editor .monaco-hover code{background-color:var(--vscode-textCodeBlock-background)}";
+var css = ".monaco-editor .hoverHighlight{background-color:var(--vscode-editor-hoverHighlightBackground)}.monaco-editor .monaco-hover{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;color:var(--vscode-editorHoverWidget-foreground)}.monaco-editor .monaco-hover a{color:var(--vscode-textLink-foreground)}.monaco-editor .monaco-hover a:hover{color:var(--vscode-textLink-activeForeground)}.monaco-editor .monaco-hover .hover-row{display:flex}.monaco-editor .monaco-hover .hover-row .hover-row-contents{display:flex;flex-direction:column;min-width:0}.monaco-editor .monaco-hover .hover-row .verbosity-actions{border-right:1px solid var(--vscode-editorHoverWidget-border);display:flex;flex-direction:column;justify-content:end;padding-left:5px;padding-right:5px}.monaco-editor .monaco-hover .hover-row .verbosity-actions .codicon{cursor:pointer;font-size:11px}.monaco-editor .monaco-hover .hover-row .verbosity-actions .codicon.enabled{color:var(--vscode-textLink-foreground)}.monaco-editor .monaco-hover .hover-row .verbosity-actions .codicon.disabled{opacity:.6}.monaco-editor .monaco-hover .hover-row .actions{background-color:var(--vscode-editorHoverWidget-statusBarBackground)}.monaco-editor .monaco-hover code{background-color:var(--vscode-textCodeBlock-background)}";
 n(css,{});
 export { css, css as default };

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

@@ -0,0 +1,13 @@
+const SHOW_OR_FOCUS_HOVER_ACTION_ID = 'editor.action.showHover';
+const SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID = 'editor.action.showDefinitionPreviewHover';
+const SCROLL_UP_HOVER_ACTION_ID = 'editor.action.scrollUpHover';
+const SCROLL_DOWN_HOVER_ACTION_ID = 'editor.action.scrollDownHover';
+const SCROLL_LEFT_HOVER_ACTION_ID = 'editor.action.scrollLeftHover';
+const SCROLL_RIGHT_HOVER_ACTION_ID = 'editor.action.scrollRightHover';
+const PAGE_UP_HOVER_ACTION_ID = 'editor.action.pageUpHover';
+const PAGE_DOWN_HOVER_ACTION_ID = 'editor.action.pageDownHover';
+const GO_TO_TOP_HOVER_ACTION_ID = 'editor.action.goToTopHover';
+const GO_TO_BOTTOM_HOVER_ACTION_ID = 'editor.action.goToBottomHover';
+const INCREASE_HOVER_VERBOSITY_ACTION_ID = 'editor.action.increaseHoverVerbosityLevel';
+const DECREASE_HOVER_VERBOSITY_ACTION_ID = 'editor.action.decreaseHoverVerbosityLevel';
+export { DECREASE_HOVER_VERBOSITY_ACTION_ID, GO_TO_BOTTOM_HOVER_ACTION_ID, GO_TO_TOP_HOVER_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID, PAGE_DOWN_HOVER_ACTION_ID, PAGE_UP_HOVER_ACTION_ID, SCROLL_DOWN_HOVER_ACTION_ID, SCROLL_LEFT_HOVER_ACTION_ID, SCROLL_RIGHT_HOVER_ACTION_ID, SCROLL_UP_HOVER_ACTION_ID, SHOW_DEFINITION_PREVIEW_HOVER_ACTION_ID, SHOW_OR_FOCUS_HOVER_ACTION_ID };