@volar/language-server - npm Package Compare versions

Comparing version 2.3.4 to 2.3.5-alpha.1

browser.d.ts

@@ -25,3 +25,3 @@ import * as vscode from 'vscode-languageserver/browser';
     shutdown: () => void;
-    watchFiles: (patterns: string[]) => void;
+    watchFiles: (patterns: string[]) => Promise<vscode.Disposable>;
     getConfiguration: <T>(section: string, scopeUri?: string) => Promise<T | undefined>;
@@ -28,0 +28,0 @@ onDidChangeConfiguration: (cb: vscode.NotificationHandler<vscode.DidChangeConfigurationParams>) => {

lib/project/typescriptProjectLs.js

@@ -13,3 +13,4 @@ "use strict";
     let projectVersion = 0;
-    const sys = (0, typescript_1.createSys)(ts.sys, serviceEnv, workspaceFolder, {
+    const getCurrentDirectory = () => asFileName(workspaceFolder);
+    const sys = (0, typescript_1.createSys)(ts.sys, serviceEnv, getCurrentDirectory, {
         asFileName,
@@ -19,5 +20,3 @@ asUri,
     const projectHost = {
-        getCurrentDirectory() {
-            return asFileName(workspaceFolder);
-        },
+        getCurrentDirectory,
         getProjectVersion() {
@@ -24,0 +23,0 @@ return projectVersion.toString();

lib/register/registerLanguageFeatures.js

@@ -10,2 +10,3 @@ "use strict";
 function registerLanguageFeatures(server) {
+    const { documentFormattingProvider, documentRangeFormattingProvider, documentOnTypeFormattingProvider, selectionRangeProvider, foldingRangeProvider, linkedEditingRangeProvider, documentSymbolProvider, colorProvider, completionProvider, hoverProvider, signatureHelpProvider, renameProvider, codeLensProvider, codeActionProvider, referencesProvider, implementationProvider, definitionProvider, typeDefinitionProvider, documentHighlightProvider, documentLinkProvider, workspaceSymbolProvider, callHierarchyProvider, semanticTokensProvider, diagnosticProvider, inlayHintProvider, executeCommandProvider, experimental, } = server.initializeResult.capabilities;
     let lastCompleteUri;
@@ -18,279 +19,389 @@ let lastCompleteLs;
     let lastInlayHintLs;
-    server.connection.onDocumentFormatting(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDocumentFormattingEdits(uri, params.options, undefined, undefined, token);
+    let languageServiceToId = new WeakMap();
+    let currentLanguageServiceId = 0;
+    const idToLanguageService = new Map();
+    if (documentFormattingProvider) {
+        server.connection.onDocumentFormatting(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDocumentFormattingEdits(uri, params.options, undefined, undefined, token);
+            });
         });
-    });
-    server.connection.onDocumentRangeFormatting(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDocumentFormattingEdits(uri, params.options, params.range, undefined, token);
+    }
+    if (documentRangeFormattingProvider) {
+        server.connection.onDocumentRangeFormatting(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDocumentFormattingEdits(uri, params.options, params.range, undefined, token);
+            });
         });
-    });
-    server.connection.onDocumentOnTypeFormatting(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDocumentFormattingEdits(uri, params.options, undefined, params, token);
+    }
+    if (documentOnTypeFormattingProvider) {
+        server.connection.onDocumentOnTypeFormatting(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDocumentFormattingEdits(uri, params.options, undefined, params, token);
+            });
         });
-    });
-    server.connection.onSelectionRanges(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getSelectionRanges(uri, params.positions, token);
+    }
+    if (selectionRangeProvider) {
+        server.connection.onSelectionRanges(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getSelectionRanges(uri, params.positions, token);
+            });
         });
-    });
-    server.connection.onFoldingRanges(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getFoldingRanges(uri, token);
+    }
+    if (foldingRangeProvider) {
+        server.connection.onFoldingRanges(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getFoldingRanges(uri, token);
+            });
         });
-    });
-    server.connection.languages.onLinkedEditingRange(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getLinkedEditingRanges(uri, params.position, token);
+    }
+    if (linkedEditingRangeProvider) {
+        server.connection.languages.onLinkedEditingRange(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getLinkedEditingRanges(uri, params.position, token);
+            });
         });
-    });
-    server.connection.onDocumentSymbol(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDocumentSymbols(uri, token);
+    }
+    if (documentSymbolProvider) {
+        server.connection.onDocumentSymbol(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDocumentSymbols(uri, token);
+            });
         });
-    });
-    server.connection.onDocumentColor(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDocumentColors(uri, token);
+    }
+    if (colorProvider) {
+        server.connection.onDocumentColor(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDocumentColors(uri, token);
+            });
         });
-    });
-    server.connection.onColorPresentation(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getColorPresentations(uri, params.color, params.range, token);
+        server.connection.onColorPresentation(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getColorPresentations(uri, params.color, params.range, token);
+            });
         });
-    });
-    server.connection.onCompletion(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, async (languageService) => {
-            lastCompleteUri = params.textDocument.uri;
-            lastCompleteLs = languageService;
-            const list = await languageService.getCompletionItems(uri, params.position, params.context, token);
-            for (const item of list.items) {
+    }
+    if (completionProvider) {
+        server.connection.onCompletion(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, async (languageService) => {
+                lastCompleteUri = params.textDocument.uri;
+                lastCompleteLs = languageService;
+                const list = await languageService.getCompletionItems(uri, params.position, params.context, token);
+                for (const item of list.items) {
+                    fixTextEdit(item);
+                }
+                return list;
+            });
+        });
+    }
+    if (completionProvider?.resolveProvider) {
+        server.connection.onCompletionResolve(async (item, token) => {
+            if (lastCompleteUri && lastCompleteLs) {
+                item = await lastCompleteLs.resolveCompletionItem(item, token);
                 fixTextEdit(item);
             }
-            return list;
+            return item;
         });
-    });
-    server.connection.onCompletionResolve(async (item, token) => {
-        if (lastCompleteUri && lastCompleteLs) {
-            item = await lastCompleteLs.resolveCompletionItem(item, token);
-            fixTextEdit(item);
-        }
-        return item;
-    });
-    server.connection.onHover(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getHover(uri, params.position, token);
+    }
+    if (hoverProvider) {
+        server.connection.onHover(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getHover(uri, params.position, token);
+            });
         });
-    });
-    server.connection.onSignatureHelp(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getSignatureHelp(uri, params.position, params.context, token);
+    }
+    if (signatureHelpProvider) {
+        server.connection.onSignatureHelp(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getSignatureHelp(uri, params.position, params.context, token);
+            });
         });
-    });
-    server.connection.onPrepareRename(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, async (languageService) => {
-            const result = await languageService.getRenameRange(uri, params.position, token);
-            if (result && 'message' in result) {
-                return new vscode.ResponseError(0, result.message);
-            }
-            return result;
+    }
+    if (renameProvider) {
+        server.connection.onRenameRequest(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getRenameEdits(uri, params.position, params.newName, token);
+            });
         });
-    });
-    server.connection.onRenameRequest(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getRenameEdits(uri, params.position, params.newName, token);
+    }
+    if (typeof renameProvider === 'object' && renameProvider.prepareProvider) {
+        server.connection.onPrepareRename(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, async (languageService) => {
+                const result = await languageService.getRenameRange(uri, params.position, token);
+                if (result && 'message' in result) {
+                    return new vscode.ResponseError(0, result.message);
+                }
+                return result;
+            });
         });
-    });
-    server.connection.onCodeLens(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            lastCodeLensLs = languageService;
-            return languageService.getCodeLenses(uri, token);
+    }
+    if (codeLensProvider) {
+        server.connection.onCodeLens(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                lastCodeLensLs = languageService;
+                return languageService.getCodeLenses(uri, token);
+            });
         });
-    });
-    server.connection.onCodeLensResolve(async (codeLens, token) => {
-        return await lastCodeLensLs?.resolveCodeLens(codeLens, token) ?? codeLens;
-    });
-    server.connection.onCodeAction(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, async (languageService) => {
-            lastCodeActionLs = languageService;
-            let codeActions = await languageService.getCodeActions(uri, params.range, params.context, token) ?? [];
-            for (const codeAction of codeActions) {
-                if (codeAction.data && typeof codeAction.data === 'object') {
-                    codeAction.data.uri = params.textDocument.uri;
+    }
+    if (codeLensProvider?.resolveProvider) {
+        server.connection.onCodeLensResolve(async (codeLens, token) => {
+            return await lastCodeLensLs?.resolveCodeLens(codeLens, token) ?? codeLens;
+        });
+    }
+    if (codeActionProvider) {
+        server.connection.onCodeAction(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, async (languageService) => {
+                lastCodeActionLs = languageService;
+                let codeActions = await languageService.getCodeActions(uri, params.range, params.context, token) ?? [];
+                for (const codeAction of codeActions) {
+                    if (codeAction.data && typeof codeAction.data === 'object') {
+                        codeAction.data.uri = params.textDocument.uri;
+                    }
+                    else {
+                        codeAction.data = { uri: params.textDocument.uri };
+                    }
                 }
-                else {
-                    codeAction.data = { uri: params.textDocument.uri };
+                if (!server.initializeParams?.capabilities.textDocument?.codeAction?.disabledSupport) {
+                    codeActions = codeActions.filter(codeAction => !codeAction.disabled);
                 }
-            }
-            if (!server.initializeParams?.capabilities.textDocument?.codeAction?.disabledSupport) {
-                codeActions = codeActions.filter(codeAction => !codeAction.disabled);
-            }
-            return codeActions;
+                return codeActions;
+            });
         });
-    });
-    server.connection.onCodeActionResolve(async (codeAction, token) => {
-        return await lastCodeActionLs?.resolveCodeAction(codeAction, token) ?? codeAction;
-    });
-    server.connection.onReferences(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getReferences(uri, params.position, { includeDeclaration: true }, token);
+    }
+    if (typeof codeActionProvider === 'object' && codeActionProvider.resolveProvider) {
+        server.connection.onCodeActionResolve(async (codeAction, token) => {
+            return await lastCodeActionLs?.resolveCodeAction(codeAction, token) ?? codeAction;
         });
-    });
-    server.connection.onRequest(protocol_1.FindFileReferenceRequest.type, async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getFileReferences(uri, token);
+    }
+    if (referencesProvider) {
+        server.connection.onReferences(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getReferences(uri, params.position, { includeDeclaration: true }, token);
+            });
         });
-    });
-    server.connection.onImplementation(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getImplementations(uri, params.position, token);
+    }
+    if (implementationProvider) {
+        server.connection.onImplementation(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getImplementations(uri, params.position, token);
+            });
         });
-    });
-    server.connection.onDefinition(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDefinition(uri, params.position, token);
+    }
+    if (definitionProvider) {
+        server.connection.onDefinition(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDefinition(uri, params.position, token);
+            });
         });
-    });
-    server.connection.onTypeDefinition(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getTypeDefinition(uri, params.position, token);
+    }
+    if (typeDefinitionProvider) {
+        server.connection.onTypeDefinition(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getTypeDefinition(uri, params.position, token);
+            });
         });
-    });
-    server.connection.onDocumentHighlight(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getDocumentHighlights(uri, params.position, token);
+    }
+    if (documentHighlightProvider) {
+        server.connection.onDocumentHighlight(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getDocumentHighlights(uri, params.position, token);
+            });
         });
-    });
-    server.connection.onDocumentLinks(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            lastDocumentLinkLs = languageService;
-            return languageService.getDocumentLinks(uri, token);
+    }
+    if (documentLinkProvider) {
+        server.connection.onDocumentLinks(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                lastDocumentLinkLs = languageService;
+                return languageService.getDocumentLinks(uri, token);
+            });
         });
-    });
-    server.connection.onDocumentLinkResolve(async (link, token) => {
-        return await lastDocumentLinkLs?.resolveDocumentLink(link, token);
-    });
-    server.connection.onWorkspaceSymbol(async (params, token) => {
-        let results = [];
-        for (const languageService of await server.project.getExistingLanguageServices()) {
-            if (token.isCancellationRequested) {
-                return;
+    }
+    if (documentLinkProvider?.resolveProvider) {
+        server.connection.onDocumentLinkResolve(async (link, token) => {
+            return await lastDocumentLinkLs?.resolveDocumentLink(link, token);
+        });
+    }
+    if (workspaceSymbolProvider) {
+        server.connection.onWorkspaceSymbol(async (params, token) => {
+            const symbols = [];
+            for (const languageService of await server.project.getExistingLanguageServices()) {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                let languageServiceId = languageServiceToId.get(languageService);
+                if (languageServiceId === undefined) {
+                    languageServiceId = currentLanguageServiceId;
+                    languageServiceToId.set(languageService, languageServiceId);
+                    idToLanguageService.set(languageServiceId, new WeakRef(languageService));
+                }
+                const languageServiceResult = await languageService.getWorkspaceSymbols(params.query, token);
+                for (const symbol of languageServiceResult) {
+                    symbol.data = {
+                        languageServiceId,
+                        originalData: symbol.data,
+                    };
+                }
+                symbols.push(...await languageService.getWorkspaceSymbols(params.query, token));
             }
-            results = results.concat(await languageService.getWorkspaceSymbols(params.query, token));
-        }
-        return results;
-    });
-    // TODO: onWorkspaceSymbolResolve
-    server.connection.languages.callHierarchy.onPrepare(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            lastCallHierarchyLs = languageService;
-            return languageService.getCallHierarchyItems(uri, params.position, token);
-        }) ?? [];
-    });
-    server.connection.languages.callHierarchy.onIncomingCalls(async (params, token) => {
-        return await lastCallHierarchyLs?.getCallHierarchyIncomingCalls(params.item, token) ?? [];
-    });
-    server.connection.languages.callHierarchy.onOutgoingCalls(async (params, token) => {
-        return await lastCallHierarchyLs?.getCallHierarchyOutgoingCalls(params.item, token) ?? [];
-    });
-    server.connection.languages.semanticTokens.on(async (params, token, _, resultProgress) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, async (languageService) => {
-            return await languageService?.getSemanticTokens(uri, undefined, server.initializeResult.capabilities.semanticTokensProvider.legend, token, tokens => resultProgress?.report(tokens));
-        }) ?? { data: [] };
-    });
-    server.connection.languages.semanticTokens.onRange(async (params, token, _, resultProgress) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, async (languageService) => {
-            return await languageService?.getSemanticTokens(uri, params.range, server.initializeResult.capabilities.semanticTokensProvider.legend, token, tokens => resultProgress?.report(tokens));
-        }) ?? { data: [] };
-    });
-    server.connection.languages.diagnostics.on(async (params, token, _workDoneProgressReporter, resultProgressReporter) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        const result = await worker(uri, token, languageService => {
-            return languageService.getDiagnostics(uri, token, errors => {
-                // resultProgressReporter is undefined in vscode
-                resultProgressReporter?.report({
-                    relatedDocuments: {
-                        [params.textDocument.uri]: {
-                            kind: vscode.DocumentDiagnosticReportKind.Full,
-                            items: errors,
+            return symbols;
+        });
+    }
+    if (typeof workspaceSymbolProvider === 'object' && workspaceSymbolProvider.resolveProvider) {
+        server.connection.onWorkspaceSymbolResolve(async (symbol, token) => {
+            const languageServiceId = symbol.data?.languageServiceId;
+            const languageService = idToLanguageService.get(languageServiceId)?.deref();
+            if (!languageService) {
+                return symbol;
+            }
+            symbol.data = symbol.data?.originalData;
+            return await languageService.resolveWorkspaceSymbol?.(symbol, token);
+        });
+    }
+    if (callHierarchyProvider) {
+        server.connection.languages.callHierarchy.onPrepare(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                lastCallHierarchyLs = languageService;
+                return languageService.getCallHierarchyItems(uri, params.position, token);
+            }) ?? [];
+        });
+        server.connection.languages.callHierarchy.onIncomingCalls(async (params, token) => {
+            return await lastCallHierarchyLs?.getCallHierarchyIncomingCalls(params.item, token) ?? [];
+        });
+        server.connection.languages.callHierarchy.onOutgoingCalls(async (params, token) => {
+            return await lastCallHierarchyLs?.getCallHierarchyOutgoingCalls(params.item, token) ?? [];
+        });
+    }
+    if (semanticTokensProvider?.full) {
+        server.connection.languages.semanticTokens.on(async (params, token, _, resultProgress) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, async (languageService) => {
+                return await languageService?.getSemanticTokens(uri, undefined, server.initializeResult.capabilities.semanticTokensProvider.legend, token, tokens => resultProgress?.report(tokens));
+            }) ?? { data: [] };
+        });
+    }
+    if (semanticTokensProvider?.range) {
+        server.connection.languages.semanticTokens.onRange(async (params, token, _, resultProgress) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, async (languageService) => {
+                return await languageService?.getSemanticTokens(uri, params.range, server.initializeResult.capabilities.semanticTokensProvider.legend, token, tokens => resultProgress?.report(tokens));
+            }) ?? { data: [] };
+        });
+    }
+    if (diagnosticProvider) {
+        server.connection.languages.diagnostics.on(async (params, token, _workDoneProgressReporter, resultProgressReporter) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            const result = await worker(uri, token, languageService => {
+                return languageService.getDiagnostics(uri, token, errors => {
+                    // resultProgressReporter is undefined in vscode
+                    resultProgressReporter?.report({
+                        relatedDocuments: {
+                            [params.textDocument.uri]: {
+                                kind: vscode.DocumentDiagnosticReportKind.Full,
+                                items: errors,
+                            },
                         },
-                    },
+                    });
                 });
             });
+            return {
+                kind: vscode.DocumentDiagnosticReportKind.Full,
+                items: result ?? [],
+            };
         });
-        return {
-            kind: vscode.DocumentDiagnosticReportKind.Full,
-            items: result ?? [],
-        };
-    });
-    server.connection.languages.diagnostics.onWorkspace(async (_params, token) => {
-        const items = [];
-        for (const languageService of await server.project.getExistingLanguageServices()) {
-            if (token.isCancellationRequested) {
-                break;
+    }
+    if (diagnosticProvider?.workspaceDiagnostics) {
+        server.connection.languages.diagnostics.onWorkspace(async (_params, token) => {
+            const items = [];
+            for (const languageService of await server.project.getExistingLanguageServices()) {
+                if (token.isCancellationRequested) {
+                    break;
+                }
+                const result = await languageService.getWorkspaceDiagnostics(token);
+                items.push(...result);
             }
-            const result = await languageService.getWorkspaceDiagnostics(token);
-            items.push(...result);
-        }
-        return { items };
-    });
-    server.connection.languages.inlayHint.on(async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            lastInlayHintLs = languageService;
-            return languageService.getInlayHints(uri, params.range, token);
+            return { items };
         });
-    });
-    server.connection.languages.inlayHint.resolve(async (hint, token) => {
-        return await lastInlayHintLs?.resolveInlayHint(hint, token) ?? hint;
-    });
-    server.connection.workspace.onWillRenameFiles(async (params, token) => {
-        const _edits = await Promise.all(params.files.map(async (file) => {
-            const oldUri = vscode_uri_1.URI.parse(file.oldUri);
-            const newUri = vscode_uri_1.URI.parse(file.newUri);
-            return await worker(oldUri, token, languageService => {
-                return languageService.getFileRenameEdits(oldUri, newUri, token) ?? null;
-            }) ?? null;
-        }));
-        const edits = _edits.filter((edit) => !!edit);
-        if (edits.length) {
-            (0, language_service_1.mergeWorkspaceEdits)(edits[0], ...edits.slice(1));
-            return edits[0];
-        }
-        return null;
-    });
-    server.connection.onRequest(protocol_1.AutoInsertRequest.type, async (params, token) => {
-        const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
-        return await worker(uri, token, languageService => {
-            return languageService.getAutoInsertSnippet(uri, params.selection, params.change, token);
+    }
+    if (inlayHintProvider) {
+        server.connection.languages.inlayHint.on(async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                lastInlayHintLs = languageService;
+                return languageService.getInlayHints(uri, params.range, token);
+            });
         });
-    });
+    }
+    if (executeCommandProvider) {
+        server.connection.onExecuteCommand(async (params, token) => {
+            for (const languageService of await server.project.getExistingLanguageServices()) {
+                if (languageService.executeCommand && languageService.getCommands().includes(params.command)) {
+                    try {
+                        return await languageService.executeCommand(params.command, params.arguments ?? [], token);
+                    }
+                    catch { }
+                }
+            }
+        });
+    }
+    if (typeof inlayHintProvider === 'object' && inlayHintProvider.resolveProvider) {
+        server.connection.languages.inlayHint.resolve(async (hint, token) => {
+            return await lastInlayHintLs?.resolveInlayHint(hint, token) ?? hint;
+        });
+    }
+    if (experimental?.fileRenameProvider) {
+        server.connection.workspace.onWillRenameFiles(async (params, token) => {
+            const _edits = await Promise.all(params.files.map(async (file) => {
+                const oldUri = vscode_uri_1.URI.parse(file.oldUri);
+                const newUri = vscode_uri_1.URI.parse(file.newUri);
+                return await worker(oldUri, token, languageService => {
+                    return languageService.getFileRenameEdits(oldUri, newUri, token) ?? null;
+                }) ?? null;
+            }));
+            const edits = _edits.filter((edit) => !!edit);
+            if (edits.length) {
+                (0, language_service_1.mergeWorkspaceEdits)(edits[0], ...edits.slice(1));
+                return edits[0];
+            }
+            return null;
+        });
+    }
+    if (experimental?.autoInsertionProvider) {
+        server.connection.onRequest(protocol_1.AutoInsertRequest.type, async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getAutoInsertSnippet(uri, params.selection, params.change, token);
+            });
+        });
+    }
+    if (experimental?.fileReferencesProvider) {
+        server.connection.onRequest(protocol_1.FindFileReferenceRequest.type, async (params, token) => {
+            const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+            return await worker(uri, token, languageService => {
+                return languageService.getFileReferences(uri, token);
+            });
+        });
+    }
     function worker(uri, token, cb) {
@@ -297,0 +408,0 @@ return new Promise(resolve => {

lib/server.d.ts

@@ -1,2 +0,2 @@
-import { FileSystem, LanguageServicePlugin } from '@volar/language-service';
+import { Disposable, FileSystem, LanguageServicePlugin } from '@volar/language-service';
 import { SnapshotDocument } from '@volar/snapshot-document';
@@ -23,3 +23,3 @@ import * as vscode from 'vscode-languageserver';
     shutdown: () => void;
-    watchFiles: (patterns: string[]) => void;
+    watchFiles: (patterns: string[]) => Promise<Disposable>;
     getConfiguration: <T>(section: string, scopeUri?: string) => Promise<T | undefined>;
@@ -26,0 +26,0 @@ onDidChangeConfiguration: (cb: vscode.NotificationHandler<vscode.DidChangeConfigurationParams>) => {

lib/server.js

@@ -29,2 +29,4 @@ "use strict";
     let documentUpdatedReq = 0;
+    let watchFilesDisposableCounter = 0;
+    let watchFilesDisposable;
     const syncedDocumentParsedUriToUri = new Map();
@@ -127,3 +129,5 @@ const didChangeWatchedFilesCallbacks = new Set();
             documentHighlightProvider: capabilitiesArr.some(data => data.documentHighlightProvider) || undefined,
-            workspaceSymbolProvider: capabilitiesArr.some(data => data.workspaceSymbolProvider) || undefined,
+            workspaceSymbolProvider: capabilitiesArr.some(data => data.workspaceSymbolProvider)
+                ? { resolveProvider: capabilitiesArr.some(data => data.workspaceSymbolProvider?.resolveProvider) || undefined }
+                : undefined,
             renameProvider: capabilitiesArr.some(data => data.renameProvider)
@@ -183,2 +187,7 @@ ? { prepareProvider: capabilitiesArr.some(data => data.renameProvider?.prepareProvider) || undefined }
                 : undefined,
+            executeCommandProvider: capabilitiesArr.some(data => data.executeCommandProvider)
+                ? {
+                    commands: [...new Set(capabilitiesArr.map(data => data.executeCommandProvider?.commands ?? []).flat())],
+                }
+                : undefined,
         };
@@ -218,3 +227,4 @@ if (!status.pullModelDiagnostics && status.initializeResult.capabilities.diagnosticProvider) {
             }
-            status.initializeResult.autoInsertion = {
+            status.initializeResult.capabilities.experimental ??= {};
+            status.initializeResult.capabilities.experimental.autoInsertionProvider = {
                 triggerCharacters: [],
@@ -225,13 +235,19 @@ configurationSections: [],
                 if (sections.size) {
-                    for (const section of sections) {
-                        status.initializeResult.autoInsertion.triggerCharacters.push(char);
-                        status.initializeResult.autoInsertion.configurationSections.push(section);
-                    }
+                    status.initializeResult.capabilities.experimental.autoInsertionProvider.triggerCharacters.push(char);
+                    status.initializeResult.capabilities.experimental.autoInsertionProvider.configurationSections.push([...sections]);
                 }
                 else {
-                    status.initializeResult.autoInsertion.triggerCharacters.push(char);
-                    status.initializeResult.autoInsertion.configurationSections.push(null);
+                    status.initializeResult.autoInsertionProvider.triggerCharacters.push(char);
+                    status.initializeResult.autoInsertionProvider.configurationSections.push(null);
                 }
             }
         }
+        if (capabilitiesArr.some(data => data.fileRenameProvider)) {
+            status.initializeResult.capabilities.experimental ??= {};
+            status.initializeResult.capabilities.experimental.fileRenameProvider = true;
+        }
+        if (capabilitiesArr.some(data => data.fileReferencesProvider)) {
+            status.initializeResult.capabilities.experimental ??= {};
+            status.initializeResult.capabilities.experimental.fileReferencesProvider = true;
+        }
         return status.initializeResult;
@@ -350,22 +366,35 @@ }
     }
-    function watchFiles(patterns) {
+    async function watchFiles(patterns) {
+        const disposables = [];
         const didChangeWatchedFiles = status.initializeParams?.capabilities.workspace?.didChangeWatchedFiles;
         const fileOperations = status.initializeParams?.capabilities.workspace?.fileOperations;
         if (didChangeWatchedFiles) {
-            connection.onDidChangeWatchedFiles(e => {
-                for (const cb of didChangeWatchedFilesCallbacks) {
-                    cb(e);
+            if (watchFilesDisposableCounter === 0) {
+                watchFilesDisposable = connection.onDidChangeWatchedFiles(e => {
+                    for (const cb of didChangeWatchedFilesCallbacks) {
+                        cb(e);
+                    }
+                });
+            }
+            watchFilesDisposableCounter++;
+            disposables.push({
+                dispose() {
+                    watchFilesDisposableCounter--;
+                    if (watchFilesDisposableCounter === 0) {
+                        watchFilesDisposable?.dispose();
+                    }
                 }
             });
-            if (didChangeWatchedFiles.dynamicRegistration) {
-                connection.client.register(vscode.DidChangeWatchedFilesNotification.type, {
-                    watchers: patterns.map(pattern => ({ globPattern: pattern })),
-                });
-            }
         }
+        if (didChangeWatchedFiles?.dynamicRegistration) {
+            disposables.push(await connection.client.register(vscode.DidChangeWatchedFilesNotification.type, {
+                watchers: patterns.map(pattern => ({ globPattern: pattern })),
+            }));
+        }
         if (fileOperations?.dynamicRegistration && fileOperations.willRename) {
-            connection.client.register(vscode.WillRenameFilesRequest.type, {
+            disposables.push(await connection.client.register(vscode.WillRenameFilesRequest.type, {
                 filters: patterns.map(pattern => ({ pattern: { glob: pattern } })),
-            });
+            }));
         }
+        return fromDisposables(disposables);
     }
@@ -458,2 +487,11 @@ function registerWorkspaceFoldersWatcher() {
 }
+function fromDisposables(disposables) {
+    return {
+        dispose() {
+            for (const disposable of disposables) {
+                disposable.dispose();
+            }
+        },
+    };
+}
 //# sourceMappingURL=server.js.map

lib/types.d.ts

@@ -11,7 +11,10 @@ import type { InitializeResult, LanguageService, ProviderResult } from '@volar/language-service';
 export type LanguageServer = ReturnType<typeof createServerBase>;
-export interface VolarInitializeResult extends InitializeResult {
-    autoInsertion?: {
+export interface VolarInitializeResult extends InitializeResult<{
+    fileReferencesProvider?: boolean;
+    fileRenameProvider?: boolean;
+    autoInsertionProvider?: {
         triggerCharacters: string[];
-        configurationSections: (string | null)[];
+        configurationSections?: (string[] | null)[];
     };
+}> {
 }

lib/types.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-;
 //# sourceMappingURL=types.js.map

node.d.ts

@@ -25,3 +25,3 @@ import { FileSystem } from '@volar/language-service';
     shutdown: () => void;
-    watchFiles: (patterns: string[]) => void;
+    watchFiles: (patterns: string[]) => Promise<vscode.Disposable>;
     getConfiguration: <T>(section: string, scopeUri?: string) => Promise<T | undefined>;
@@ -28,0 +28,0 @@ onDidChangeConfiguration: (cb: vscode.NotificationHandler<vscode.DidChangeConfigurationParams>) => {

package.json

 {
 	"name": "@volar/language-server",
-	"version": "2.3.4",
+	"version": "2.3.5-alpha.1",
 	"license": "MIT",
@@ -15,6 +15,6 @@ "files": [
 	"dependencies": {
-		"@volar/language-core": "2.3.4",
-		"@volar/language-service": "2.3.4",
-		"@volar/snapshot-document": "2.3.4",
-		"@volar/typescript": "2.3.4",
+		"@volar/language-core": "2.3.5-alpha.1",
+		"@volar/language-service": "2.3.5-alpha.1",
+		"@volar/snapshot-document": "2.3.5-alpha.1",
+		"@volar/typescript": "2.3.5-alpha.1",
 		"path-browserify": "^1.0.1",
@@ -30,3 +30,3 @@ "request-light": "^0.7.0",
 	},
-	"gitHead": "ba5b381923bbc8a565e84de72fa98474501fe817"
+	"gitHead": "111bfae316c66a087a497e12740d46fc2c74cab0"
 }

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

114835

increased by6.91%

Lines of code

2400

increased by6.76%

Worsened metrics

Number of low quality alerts

2

increased by100%

Dependency changes

• + Added@volar/language-core@2.3.5-alpha.1(transitive)

• + Added@volar/language-service@2.3.5-alpha.1(transitive)

• + Added@volar/snapshot-document@2.3.5-alpha.1(transitive)

• + Added@volar/source-map@2.3.5-alpha.1(transitive)

• + Added@volar/typescript@2.3.5-alpha.1(transitive)

• - Removed@volar/language-core@2.3.4(transitive)

• - Removed@volar/language-service@2.3.4(transitive)

• - Removed@volar/snapshot-document@2.3.4(transitive)

• - Removed@volar/source-map@2.3.4(transitive)

• - Removed@volar/typescript@2.3.4(transitive)

• Updated@volar/language-core@2.3.5-alpha.1

• Updated@volar/language-service@2.3.5-alpha.1

• Updated@volar/snapshot-document@2.3.5-alpha.1

• Updated@volar/typescript@2.3.5-alpha.1