@mirascript/monaco 0.1.39 → 0.1.40

package/src/lsp/providers/hover-provider.ts

@@ -1,8 +1,37 @@
-import type { CancellationToken, editor, IMarkdownString, IRange, languages, Position } from '../../monaco-api.js';
+import type { editor, CancellationToken, IMarkdownString, IRange, languages, Position } from '../../monaco-api.js';
 import { Provider } from './base.js';
 import { DiagnosticCode } from '@mirascript/constants';
 import { codeblock, getDeep, valueDoc, paramsList } from '../utils.js';
+import { tokenAt } from '../monaco-private.js';
 import type { FieldsAccessAt, VariableAccessAt } from '../compile-result.js';
+import { KEYWORDS as HELP_KEYWORDS, OPERATORS as HELP_OPERATORS } from '@mirascript/help';
+
+const OPERATOR_TOKENS_DESC = Object.keys(HELP_OPERATORS as Record<string, string>).sort((a, b) => b.length - a.length);
+
+/** 在指定位置查找操作符 */
+function operatorAt(lineContent: string, column: number): { token: string; range: IRange } | undefined {
+    const index = Math.max(0, column - 1);
+    for (const token of OPERATOR_TOKENS_DESC) {
+        for (let offset = 0; offset < token.length; offset++) {
+            const start = index - offset;
+            if (start < 0) continue;
+            const end = start + token.length;
+            if (end > lineContent.length) continue;
+            if (lineContent.slice(start, end) !== token) continue;
+            if (index < start || index >= end) continue;
+            return {
+                token,
+                range: {
+                    startLineNumber: 0,
+                    startColumn: start + 1,
+                    endLineNumber: 0,
+                    endColumn: end + 1,
+                },
+            };
+        }
+    }
+    return undefined;
+}
 
 /** @inheritdoc */
 export class HoverProvider extends Provider implements languages.HoverProvider {
@@ -120,6 +149,61 @@ export class HoverProvider extends Provider implements languages.HoverProvider {
             range,
         };
     }
+
+    /** 语法元素提示 */
+    private provideSyntaxHover(model: editor.ITextModel, position: Position): languages.Hover | undefined {
+        const token = tokenAt(model, position);
+        if (token?.type && token.type !== 'other') {
+            return undefined;
+        }
+
+        if (token?.text && (token.text in HELP_KEYWORDS || token.text in HELP_OPERATORS)) {
+            const doc =
+                HELP_KEYWORDS[token.text as keyof typeof HELP_KEYWORDS] ??
+                HELP_OPERATORS[token.text as keyof typeof HELP_OPERATORS];
+            return {
+                contents: [{ value: doc }],
+                range: {
+                    startLineNumber: position.lineNumber,
+                    endLineNumber: position.lineNumber,
+                    startColumn: token.startColumn,
+                    endColumn: token.endColumn,
+                },
+            };
+        }
+
+        const word = model.getWordAtPosition(position);
+        if (word?.word && word.word in HELP_KEYWORDS) {
+            const doc = HELP_KEYWORDS[word.word as keyof typeof HELP_KEYWORDS];
+            return {
+                contents: [{ value: doc }],
+                range: {
+                    startLineNumber: position.lineNumber,
+                    endLineNumber: position.lineNumber,
+                    startColumn: word.startColumn,
+                    endColumn: word.endColumn,
+                },
+            };
+        }
+
+        const lineContent = model.getLineContent(position.lineNumber);
+        const hit = operatorAt(lineContent, position.column);
+        if (hit && hit.token in HELP_OPERATORS) {
+            const doc = HELP_OPERATORS[hit.token as keyof typeof HELP_OPERATORS];
+            return {
+                contents: [{ value: doc }],
+                range: {
+                    startLineNumber: position.lineNumber,
+                    endLineNumber: position.lineNumber,
+                    startColumn: hit.range.startColumn,
+                    endColumn: hit.range.endColumn,
+                },
+            };
+        }
+
+        return undefined;
+    }
+
     /** @inheritdoc */
     async provideHover(
         model: editor.ITextModel,
@@ -128,8 +212,9 @@ export class HoverProvider extends Provider implements languages.HoverProvider {
         context?: languages.HoverContext<languages.Hover>,
     ): Promise<languages.Hover | undefined> {
         const value = await this.getValueAt(model, position);
-        if (!value) return undefined;
-        if ('fields' in value) {
+        if (!value) {
+            return this.provideSyntaxHover(model, position);
+        } else if ('fields' in value) {
             return this.provideFieldHover(model, value.range, value.fields);
         } else {
             return this.provideVariableHover(model, value.variable);

package/src/lsp/providers/signature-help-provider.ts

@@ -1,8 +1,9 @@
 import { DiagnosticCode } from '@mirascript/constants';
+import { getVmFunctionInfo } from '@mirascript/mirascript';
 import { type editor, type languages, type CancellationToken, Position, Range } from '../../monaco-api.js';
 import { Provider } from './base.js';
-import { fnSignature, getDeep, localParamSignature, strictContainsPosition } from '../utils.js';
-import { getVmFunctionInfo } from '@mirascript/mirascript';
+import { fnSignature, getDeep, localParamSignature } from '../utils.js';
+import { strictContainsPosition } from '../monaco-utils.js';
 
 /** @inheritdoc */
 export class SignatureHelpProvider extends Provider implements languages.SignatureHelpProvider {

package/src/lsp/utils.ts

@@ -1,5 +1,5 @@
 import { DiagnosticCode } from '@mirascript/constants';
-import { type editor, Range, type IPosition, type IRange } from '../monaco-api.js';
+import { type editor, Range } from '../monaco-api.js';
 import {
     getVmFunctionInfo,
     isVmArray,
@@ -155,19 +155,6 @@ export function codeblock(value: string): string {
     return `\n${CODEBLOCK_FENCE}${lang}\n${value}\n${CODEBLOCK_FENCE}\n`;
 }
 
-/** 检查位置是否在范围内，且范围非空 */
-export function strictContainsPosition(range: IRange, position: IPosition): boolean {
-    return !Range.isEmpty(range) && Range.containsPosition(range, position);
-}
-
-/** 获取单词 */
-export function wordAt(model: editor.ITextModel, position: IPosition): { word: string; range: Range } | undefined {
-    const word = model.getWordAtPosition(position);
-    if (!word) return undefined;
-    const range = new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
-    return { word: word.word, range };
-}
-
 /** 将值序列化为便于展示的字符串 */
 function serializeForDisplayInner(value: VmValue, maxWidth: number): string {
     if (maxWidth < 10) maxWidth = 10;