feat: completed provideHover

package.json

@@ -48,7 +48,7 @@
     "sucrase": "^3.20.1",
     "typescript": "^4.5.4",
     "vite": "^2.6.5",
-    "vscode-languageserver-types": "^3.17.1",
+    "vscode-languageserver-protocol": "^3.17.1",
     "vue": "^3.2.37",
     "vue-tsc": "^0.37.3"
   },

src/monaco/code2monaco.ts

@@ -1,5 +1,5 @@
 import * as monaco from 'monaco-editor';
-import * as vscode from 'vscode-languageserver-types';
+import * as vscode from 'vscode-languageserver-protocol';
 
 export function asCompletionList(list: vscode.CompletionList): monaco.languages.CompletionList {
     return {
@@ -121,3 +121,22 @@ export function asRange(range: vscode.Range): monaco.IRange {
         endColumn: range.end.character + 1,
     };
 }
+
+export function asHover(hover: vscode.Hover): monaco.languages.Hover {
+    return {
+        contents: asMarkdownString(hover.contents),
+        range: hover.range ? asRange(hover.range) : undefined,
+    };
+}
+
+export function asMarkdownString(markdownString: vscode.Hover['contents']): monaco.IMarkdownString[] {
+    if (typeof markdownString === 'string') {
+        return [{ value: markdownString }]
+    }
+    else if (Array.isArray(markdownString)) {
+        return markdownString.map(asMarkdownString).flat();
+    }
+    else {
+        return [markdownString];
+    }
+}

src/monaco/ls.ts

@@ -1,11 +1,12 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import * as monaco from 'monaco-editor';
-import type * as vscode from 'vscode-languageserver-types';
+import type * as vscode from 'vscode-languageserver-protocol';
 import * as ts from 'typescript/lib/tsserverlibrary';
 import { createLanguageService, type LanguageService, type LanguageServiceHost } from '@volar/vue-language-service';
 import type { Ref } from 'vue';
 import { onBeforeUnmount, ref } from 'vue';
 import * as code2monaco from './code2monaco';
+import * as monaco2code from './monaco2code';
 import libEs5Content from 'typescript/lib/lib.es5.d.ts?raw';
 import libDomContent from 'typescript/lib/lib.dom.d.ts?raw';
 import libDtsContent from 'typescript/lib/lib.d.ts?raw';
@@ -199,15 +200,9 @@ export async function setupLs(modelsMap: Ref<Map<string, monaco.editor.ITextMode
             triggerCharacters: '!@#$%^&*()_+-=`~{}|[]\:";\'<>?,./ '.split(''),
             provideCompletionItems: async (model, position, context) => {
                 const codeResult = await ls.doComplete(
-                    model.uri.fsPath,
-                    {
-                        line: position.lineNumber - 1,
-                        character: position.column - 1,
-                    },
-                    {
-                        triggerKind: (context.triggerKind + 1) as any,
-                        triggerCharacter: context.triggerCharacter,
-                    },
+                    model.uri.toString(),
+                    monaco2code.asPosition(position),
+                    monaco2code.asCompletionContext(context),
                 );
                 const monacoResult = code2monaco.asCompletionList(codeResult);
                 for (let i = 0; i < codeResult.items.length; i++) {
@@ -232,33 +227,21 @@ export async function setupLs(modelsMap: Ref<Map<string, monaco.editor.ITextMode
     disposables.value.push(
         monaco.languages.registerHoverProvider(lang, {
             provideHover: async (model, position) => {
-                const info: vscode.Hover | undefined = await ls.doHover(model.uri.fsPath, {
-                    line: position.lineNumber - 1,
-                    character: position.column - 1,
-                });
-                if (!info) {
-                    return undefined;
+                const codeResult = await ls.doHover(
+                    model.uri.toString(),
+                    monaco2code.asPosition(position),
+                );
+                if (codeResult) {
+                    return code2monaco.asHover(codeResult);
                 }
-                const results: monaco.languages.Hover = {
-                    contents: (Array.isArray(info.contents)
-                        ? (info.contents as string[])
-                        : typeof info.contents === 'string'
-                            ? [info.contents]
-                            : [info.contents.value]
-                    ).map((x) => ({
-                        value: x,
-                    })),
-                };
-
-                return results;
             },
         }),
     );
 
     disposables.value.push(
         monaco.languages.registerDefinitionProvider(lang, {
             provideDefinition: async (model, position) => {
-                const result = await ls.findDefinition(model.uri.fsPath, {
+                const result = await ls.findDefinition(model.uri.toString(), {
                     line: position.lineNumber - 1,
                     character: position.column - 1,
                 });
@@ -288,7 +271,7 @@ export async function setupLs(modelsMap: Ref<Map<string, monaco.editor.ITextMode
         monaco.languages.registerSignatureHelpProvider(lang, {
             signatureHelpTriggerCharacters: ['(', ','],
             provideSignatureHelp: async (model, position) => {
-                const result = await ls.getSignatureHelp(model.uri.fsPath, {
+                const result = await ls.getSignatureHelp(model.uri.toString(), {
                     line: position.lineNumber - 1,
                     character: position.column - 1,
                 });
@@ -326,7 +309,7 @@ export function setupValidate(editor: monaco.editor.IStandaloneCodeEditor, ls: L
             throw new Error('No model');
         }
 
-        const diagnostics = await ls.doValidation(model.uri.fsPath);
+        const diagnostics = await ls.doValidation(model.uri.toString());
         monaco.editor.setModelMarkers(
             model,
             lang,

src/monaco/monaco2code.ts

@@ -0,0 +1,35 @@
+import * as monaco from 'monaco-editor';
+import * as vscode from 'vscode-languageserver-protocol';
+
+export function asPosition(position: monaco.Position): vscode.Position {
+    return vscode.Position.create(
+        position.lineNumber - 1, position.column - 1,
+    );
+}
+
+export function asRange(range: monaco.Range): vscode.Range {
+    return vscode.Range.create(
+        range.startLineNumber - 1,
+        range.startColumn - 1,
+        range.endLineNumber - 1,
+        range.endColumn - 1,
+    );
+}
+
+export function asCompletionContext(context: monaco.languages.CompletionContext): vscode.CompletionContext {
+    return {
+        triggerKind: asTriggerKind(context.triggerKind),
+        triggerCharacter: context.triggerCharacter,
+    };
+}
+
+export function asTriggerKind(kind: monaco.languages.CompletionTriggerKind): vscode.CompletionTriggerKind {
+    switch (kind) {
+        case monaco.languages.CompletionTriggerKind.Invoke:
+            return vscode.CompletionTriggerKind.Invoked;
+        case monaco.languages.CompletionTriggerKind.TriggerCharacter:
+            return vscode.CompletionTriggerKind.TriggerCharacter;
+        case monaco.languages.CompletionTriggerKind.TriggerForIncompleteCompletions:
+            return vscode.CompletionTriggerKind.TriggerForIncompleteCompletions;
+    }
+}