@vue/language-server 3.0.0-alpha.8 → 3.0.0-beta.2

package/bin/vue-language-server.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-// @ts-check
+
 if (process.argv.includes('--version')) {
 	console.log(require('../package.json').version);
+	return;
 }
-else {
-	require('../node.js');
-}
+
+require('../index.js');

package/index.d.ts

@@ -1,3 +1 @@
-export * from './lib/types';
-export * from '@volar/language-server/lib/types';
-export * from '@vue/language-service/lib/types';
+export {};

package/index.js

@@ -1,22 +1,312 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/types"), exports);
-// export types of parent package
-__exportStar(require("@volar/language-server/lib/types"), exports);
-// only export types of depend packages
-__exportStar(require("@vue/language-service/lib/types"), exports);
+const language_server_1 = require("@volar/language-server");
+const simpleProject_1 = require("@volar/language-server/lib/project/simpleProject");
+const node_1 = require("@volar/language-server/node");
+const language_core_1 = require("@vue/language-core");
+const language_service_1 = require("@vue/language-service");
+const ts = require("typescript");
+const vscode_uri_1 = require("vscode-uri");
+const reactionsAnalyze_1 = require("./lib/reactionsAnalyze");
+const reactionsAnalyzeLS_1 = require("./lib/reactionsAnalyzeLS");
+const connection = (0, node_1.createConnection)();
+const server = (0, node_1.createServer)(connection);
+connection.listen();
+connection.onInitialize(params => {
+    const tsconfigProjects = (0, language_service_1.createUriMap)();
+    const file2ProjectInfo = new Map();
+    server.fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
+        for (const change of changes) {
+            const changeUri = vscode_uri_1.URI.parse(change.uri);
+            if (tsconfigProjects.has(changeUri)) {
+                tsconfigProjects.get(changeUri).dispose();
+                tsconfigProjects.delete(changeUri);
+                file2ProjectInfo.clear();
+            }
+        }
+    });
+    let simpleLs;
+    let tsserverRequestId = 0;
+    const tsserverRequestHandlers = new Map();
+    connection.onNotification('tsserver/response', ([id, res]) => {
+        tsserverRequestHandlers.get(id)?.(res);
+        tsserverRequestHandlers.delete(id);
+    });
+    return server.initialize(params, {
+        setup() { },
+        async getLanguageService(uri) {
+            if (uri.scheme === 'file') {
+                const fileName = uri.fsPath.replace(/\\/g, '/');
+                let projectInfoPromise = file2ProjectInfo.get(fileName);
+                if (!projectInfoPromise) {
+                    projectInfoPromise = sendTsRequest(ts.server.protocol.CommandTypes.ProjectInfo, {
+                        file: fileName,
+                        needFileNameList: false,
+                    });
+                    file2ProjectInfo.set(fileName, projectInfoPromise);
+                }
+                const projectInfo = await projectInfoPromise;
+                if (projectInfo) {
+                    const { configFileName } = projectInfo;
+                    let ls = tsconfigProjects.get(vscode_uri_1.URI.file(configFileName));
+                    if (!ls) {
+                        ls = createLs(server, configFileName);
+                        tsconfigProjects.set(vscode_uri_1.URI.file(configFileName), ls);
+                    }
+                    return ls;
+                }
+            }
+            return simpleLs ??= createLs(server, undefined);
+        },
+        getExistingLanguageServices() {
+            return Promise.all([
+                ...tsconfigProjects.values(),
+                simpleLs,
+            ].filter(promise => !!promise));
+        },
+        reload() {
+            for (const ls of tsconfigProjects.values()) {
+                ls.dispose();
+            }
+            tsconfigProjects.clear();
+            if (simpleLs) {
+                simpleLs.dispose();
+                simpleLs = undefined;
+            }
+        },
+    }, (0, language_service_1.createVueLanguageServicePlugins)(ts, {
+        collectExtractProps(...args) {
+            return sendTsRequest('vue:collectExtractProps', args);
+        },
+        getComponentDirectives(...args) {
+            return sendTsRequest('vue:getComponentDirectives', args);
+        },
+        getComponentEvents(...args) {
+            return sendTsRequest('vue:getComponentEvents', args);
+        },
+        getComponentNames(...args) {
+            return sendTsRequest('vue:getComponentNames', args);
+        },
+        getComponentProps(...args) {
+            return sendTsRequest('vue:getComponentProps', args);
+        },
+        getElementAttrs(...args) {
+            return sendTsRequest('vue:getElementAttrs', args);
+        },
+        getElementNames(...args) {
+            return sendTsRequest('vue:getElementNames', args);
+        },
+        getImportPathForFile(...args) {
+            return sendTsRequest('vue:getImportPathForFile', args);
+        },
+        getPropertiesAtLocation(...args) {
+            return sendTsRequest('vue:getPropertiesAtLocation', args);
+        },
+        getDocumentHighlights(fileName, position) {
+            return sendTsRequest('documentHighlights-full', // internal command
+            {
+                file: fileName,
+                ...{ position },
+                filesToSearch: [fileName],
+            });
+        },
+        async getQuickInfoAtPosition(fileName, { line, character }) {
+            const result = await sendTsRequest(ts.server.protocol.CommandTypes.Quickinfo, {
+                file: fileName,
+                line: line + 1,
+                offset: character + 1,
+            });
+            return ts.displayPartsToString(result?.displayParts ?? []);
+        },
+    }));
+    async function sendTsRequest(command, args) {
+        return await new Promise(resolve => {
+            const requestId = ++tsserverRequestId;
+            tsserverRequestHandlers.set(requestId, resolve);
+            connection.sendNotification('tsserver/request', [requestId, command, args]);
+        });
+    }
+    function createLs(server, tsconfig) {
+        const commonLine = tsconfig
+            ? (0, language_core_1.createParsedCommandLine)(ts, ts.sys, tsconfig)
+            : {
+                options: ts.getDefaultCompilerOptions(),
+                vueOptions: (0, language_core_1.getDefaultCompilerOptions)(),
+            };
+        const language = (0, language_core_1.createLanguage)([
+            {
+                getLanguageId: uri => server.documents.get(uri)?.languageId,
+            },
+            (0, language_core_1.createVueLanguagePlugin)(ts, commonLine.options, commonLine.vueOptions, uri => uri.fsPath.replace(/\\/g, '/')),
+        ], (0, language_service_1.createUriMap)(), uri => {
+            const document = server.documents.get(uri);
+            if (document) {
+                language.scripts.set(uri, document.getSnapshot(), document.languageId);
+            }
+            else {
+                language.scripts.delete(uri);
+            }
+        });
+        return (0, language_service_1.createLanguageService)(language, server.languageServicePlugins, (0, simpleProject_1.createLanguageServiceEnvironment)(server, [...server.workspaceFolders.all]), { vue: { compilerOptions: commonLine.vueOptions } });
+    }
+});
+connection.onInitialized(server.initialized);
+connection.onShutdown(server.shutdown);
+connection.onRequest('vue/parseSfc', (params) => {
+    const document = server.documents.get(vscode_uri_1.URI.parse(params.textDocument.uri));
+    if (document) {
+        return (0, language_core_1.parse)(document.getText());
+    }
+});
+connection.onRequest('vue/interpolationRanges', async (params) => {
+    const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+    const languageService = await server.project.getLanguageService(uri);
+    if (languageService) {
+        const sourceFile = languageService.context.language.scripts.get(uri);
+        if (sourceFile?.generated) {
+            const ranges = [];
+            for (const code of (0, language_core_1.forEachEmbeddedCode)(sourceFile.generated.root)) {
+                const codeText = code.snapshot.getText(0, code.snapshot.getLength());
+                if ((code.id.startsWith('template_inline_ts_')
+                    && codeText.startsWith('0 +')
+                    && codeText.endsWith('+ 0;'))
+                    || (code.id.startsWith('style_') && code.id.endsWith('_inline_ts'))) {
+                    for (const mapping of code.mappings) {
+                        for (let i = 0; i < mapping.sourceOffsets.length; i++) {
+                            ranges.push([
+                                mapping.sourceOffsets[i],
+                                mapping.sourceOffsets[i] + mapping.lengths[i],
+                            ]);
+                        }
+                    }
+                }
+            }
+            return ranges;
+        }
+    }
+    return [];
+});
+const cacheDocuments = new Map();
+connection.onRequest('vue/reactionsAnalyze', async (params) => {
+    if (params.syncDocument) {
+        const document = language_server_1.TextDocument.create(params.textDocument.uri, params.syncDocument.languageId, 0, params.syncDocument.content);
+        const snapshot = ts.ScriptSnapshot.fromString(params.syncDocument.content);
+        cacheDocuments.set(params.textDocument.uri, [document, snapshot]);
+    }
+    const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+    const languageService = await server.project.getLanguageService(uri);
+    const sourceScript = languageService.context.language.scripts.get(uri);
+    let document;
+    let snapshot;
+    if (sourceScript) {
+        document = languageService.context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot);
+        snapshot = sourceScript.snapshot;
+    }
+    else if (cacheDocuments.has(params.textDocument.uri)) {
+        const [doc, snap] = cacheDocuments.get(params.textDocument.uri);
+        document = doc;
+        snapshot = snap;
+    }
+    if (!document || !snapshot) {
+        return;
+    }
+    let offset = document.offsetAt(params.position);
+    if (sourceScript?.generated) {
+        const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+        if (!serviceScript) {
+            return;
+        }
+        const map = languageService.context.language.maps.get(serviceScript.code, sourceScript);
+        let embeddedOffset;
+        for (const [mapped, mapping] of map.toGeneratedLocation(offset)) {
+            if ((0, language_core_1.isReferencesEnabled)(mapping.data)) {
+                embeddedOffset = mapped;
+                break;
+            }
+        }
+        if (embeddedOffset === undefined) {
+            return;
+        }
+        offset = embeddedOffset;
+        const embeddedUri = languageService.context.encodeEmbeddedDocumentUri(sourceScript.id, serviceScript.code.id);
+        document = languageService.context.documents.get(embeddedUri, serviceScript.code.languageId, serviceScript.code.snapshot);
+        snapshot = serviceScript.code.snapshot;
+    }
+    const { languageService: tsLs, fileName } = (0, reactionsAnalyzeLS_1.getLanguageService)(ts, snapshot, document.languageId);
+    const result = (0, reactionsAnalyze_1.analyze)(ts, tsLs, fileName, offset);
+    if (!result) {
+        return;
+    }
+    const subscribers = [];
+    const dependencies = [];
+    if (sourceScript?.generated) {
+        const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+        if (!serviceScript) {
+            return;
+        }
+        const docs = [
+            languageService.context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot),
+            document,
+            languageService.context.language.maps.get(serviceScript.code, sourceScript),
+        ];
+        for (const dependency of result.dependencies) {
+            let start = document.positionAt(dependency.getStart(result.sourceFile));
+            let end = document.positionAt(dependency.getEnd());
+            if (ts.isBlock(dependency) && dependency.statements.length) {
+                const { statements } = dependency;
+                start = document.positionAt(statements[0].getStart(result.sourceFile));
+                end = document.positionAt(statements[statements.length - 1].getEnd());
+            }
+            const sourceRange = (0, language_service_1.getSourceRange)(docs, { start, end });
+            if (sourceRange) {
+                dependencies.push(sourceRange);
+            }
+        }
+        for (const subscriber of result.subscribers) {
+            if (!subscriber.sideEffectInfo) {
+                continue;
+            }
+            let start = document.positionAt(subscriber.sideEffectInfo.handler.getStart(result.sourceFile));
+            let end = document.positionAt(subscriber.sideEffectInfo.handler.getEnd());
+            if (ts.isBlock(subscriber.sideEffectInfo.handler) && subscriber.sideEffectInfo.handler.statements.length) {
+                const { statements } = subscriber.sideEffectInfo.handler;
+                start = document.positionAt(statements[0].getStart(result.sourceFile));
+                end = document.positionAt(statements[statements.length - 1].getEnd());
+            }
+            const sourceRange = (0, language_service_1.getSourceRange)(docs, { start, end });
+            if (sourceRange) {
+                subscribers.push(sourceRange);
+            }
+        }
+    }
+    else {
+        for (const dependency of result.dependencies) {
+            let start = document.positionAt(dependency.getStart(result.sourceFile));
+            let end = document.positionAt(dependency.getEnd());
+            if (ts.isBlock(dependency) && dependency.statements.length) {
+                const { statements } = dependency;
+                start = document.positionAt(statements[0].getStart(result.sourceFile));
+                end = document.positionAt(statements[statements.length - 1].getEnd());
+            }
+            dependencies.push({ start, end });
+        }
+        for (const subscriber of result.subscribers) {
+            if (!subscriber.sideEffectInfo) {
+                continue;
+            }
+            let start = document.positionAt(subscriber.sideEffectInfo.handler.getStart(result.sourceFile));
+            let end = document.positionAt(subscriber.sideEffectInfo.handler.getEnd());
+            if (ts.isBlock(subscriber.sideEffectInfo.handler) && subscriber.sideEffectInfo.handler.statements.length) {
+                const { statements } = subscriber.sideEffectInfo.handler;
+                start = document.positionAt(statements[0].getStart(result.sourceFile));
+                end = document.positionAt(statements[statements.length - 1].getEnd());
+            }
+            subscribers.push({ start, end });
+        }
+    }
+    return {
+        subscribers,
+        dependencies,
+    };
+});
 //# sourceMappingURL=index.js.map

package/lib/reactionsAnalyze.d.ts

@@ -0,0 +1,27 @@
+import type * as ts from 'typescript';
+declare const enum TrackKind {
+    AccessDotValue = 0,
+    AccessAnyValue = 1,
+    Call = 2
+}
+interface SignalNode {
+    bindingInfo?: {
+        isRef: boolean;
+        name: ts.BindingName;
+        trackKinds: TrackKind[];
+    };
+    trackInfo?: {
+        depsHandler: ts.Node;
+        needToUse: boolean;
+    };
+    sideEffectInfo?: {
+        isEffect: boolean;
+        handler: ts.Node;
+    };
+}
+export declare function analyze(ts: typeof import('typescript'), languageService: ts.LanguageService, fileName: string, position: number): {
+    sourceFile: ts.SourceFile;
+    subscribers: SignalNode[];
+    dependencies: ts.Node[];
+} | undefined;
+export {};

package/lib/reactionsAnalyze.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyze = analyze;
+const language_core_1 = require("@vue/language-core");
+function analyze(ts, languageService, fileName, position) {
+    const sourceFile = languageService.getProgram().getSourceFile(fileName);
+    const { signals, dotValueAccesses, dotAnyAccesses, functionCalls } = collect(ts, sourceFile);
+    let signal = findSignalByNamePosition(position);
+    if (!signal) {
+        signal = findEffectByEffectHandlerPosition(position);
+        if (signal?.bindingInfo) {
+            position = signal.bindingInfo.name.getStart(sourceFile);
+        }
+    }
+    if (!signal) {
+        return;
+    }
+    const subscribers = signal.bindingInfo
+        ? findSubscribers(signal.bindingInfo.name, signal.bindingInfo.trackKinds)
+        : [];
+    const dependencies = signal
+        ? findDependencies(signal)
+        : [];
+    if ((!signal.sideEffectInfo?.isEffect && !subscribers.length)
+        || (!signal.bindingInfo?.isRef && !dependencies.length)) {
+        return;
+    }
+    return {
+        sourceFile,
+        subscribers: [...new Set(subscribers)],
+        dependencies: [...new Set(dependencies)],
+    };
+    function findDependencies(signal, visited = new Set()) {
+        if (visited.has(signal)) {
+            return [];
+        }
+        visited.add(signal);
+        const nodes = [];
+        let hasRef = signal.bindingInfo?.isRef ?? false;
+        if (signal.trackInfo) {
+            const { needToUse } = signal.trackInfo;
+            visit(signal.trackInfo.depsHandler, needToUse);
+            signal.trackInfo.depsHandler.forEachChild(child => visit(child, needToUse));
+        }
+        if (!hasRef) {
+            return [];
+        }
+        return nodes;
+        function visit(node, needToUse, parentIsPropertyAccess = false) {
+            if (!needToUse) {
+                if (!parentIsPropertyAccess && ts.isIdentifier(node)) {
+                    const definition = languageService.getDefinitionAtPosition(fileName, node.getStart(sourceFile));
+                    for (const info of definition ?? []) {
+                        if (info.fileName !== fileName) {
+                            continue;
+                        }
+                        const signal = findSignalByNamePosition(info.textSpan.start);
+                        if (!signal) {
+                            continue;
+                        }
+                        if (signal.bindingInfo) {
+                            nodes.push(signal.bindingInfo.name);
+                            hasRef ||= signal.bindingInfo.isRef;
+                        }
+                        if (signal.sideEffectInfo) {
+                            nodes.push(signal.sideEffectInfo.handler);
+                        }
+                        const deps = findDependencies(signal, visited);
+                        nodes.push(...deps);
+                        hasRef ||= deps.length > 0;
+                    }
+                }
+            }
+            else if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node) || ts.isCallExpression(node)) {
+                const definition = languageService.getDefinitionAtPosition(fileName, node.expression.getStart(sourceFile));
+                for (const info of definition ?? []) {
+                    if (info.fileName !== fileName) {
+                        continue;
+                    }
+                    const signal = findSignalByNamePosition(info.textSpan.start);
+                    if (!signal) {
+                        continue;
+                    }
+                    const oldSize = nodes.length;
+                    if (signal.bindingInfo) {
+                        for (const trackKind of signal.bindingInfo.trackKinds) {
+                            if (ts.isPropertyAccessExpression(node)) {
+                                if (trackKind === 0 /* TrackKind.AccessDotValue */ && node.name.text === 'value') {
+                                    nodes.push(signal.bindingInfo.name);
+                                    hasRef ||= signal.bindingInfo.isRef;
+                                }
+                                if (trackKind === 1 /* TrackKind.AccessAnyValue */ && node.name.text !== '') {
+                                    nodes.push(signal.bindingInfo.name);
+                                    hasRef ||= signal.bindingInfo.isRef;
+                                }
+                            }
+                            else if (ts.isElementAccessExpression(node)) {
+                                if (trackKind === 1 /* TrackKind.AccessAnyValue */) {
+                                    nodes.push(signal.bindingInfo.name);
+                                    hasRef ||= signal.bindingInfo.isRef;
+                                }
+                            }
+                            else if (ts.isCallExpression(node)) {
+                                if (trackKind === 2 /* TrackKind.Call */) {
+                                    nodes.push(signal.bindingInfo.name);
+                                    hasRef ||= signal.bindingInfo.isRef;
+                                }
+                            }
+                        }
+                    }
+                    const signalDetected = nodes.length > oldSize;
+                    if (signalDetected) {
+                        if (signal.sideEffectInfo) {
+                            nodes.push(signal.sideEffectInfo.handler);
+                        }
+                        const deps = findDependencies(signal, visited);
+                        nodes.push(...deps);
+                        hasRef ||= deps.length > 0;
+                    }
+                }
+            }
+            node.forEachChild(child => visit(child, needToUse, ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)));
+        }
+        ;
+    }
+    function findSubscribers(refName, trackKinds, visited = new Set()) {
+        return (0, language_core_1.findBindingVars)(ts, refName, sourceFile)
+            .map(binding => findSubscribersWorker(binding, trackKinds, visited))
+            .flat();
+    }
+    function findSubscribersWorker(refName, trackKinds, visited = new Set()) {
+        if (visited.has(refName.start)) {
+            return [];
+        }
+        visited.add(refName.start);
+        const references = languageService.findReferences(fileName, refName.start);
+        if (!references) {
+            return [];
+        }
+        const result = [];
+        for (const reference of references) {
+            for (const reference2 of reference.references) {
+                if (reference2.fileName !== fileName) {
+                    continue;
+                }
+                const effect = findEffectByDepsHandlerPosition(reference2.textSpan.start);
+                if (effect?.trackInfo) {
+                    if (effect.trackInfo.needToUse) {
+                        let match = false;
+                        for (const trackKind of trackKinds) {
+                            if (trackKind === 1 /* TrackKind.AccessAnyValue */) {
+                                match = dotAnyAccesses.has(reference2.textSpan.start + reference2.textSpan.length);
+                            }
+                            else if (trackKind === 0 /* TrackKind.AccessDotValue */) {
+                                match = dotValueAccesses.has(reference2.textSpan.start + reference2.textSpan.length);
+                            }
+                            else if (trackKind === 2 /* TrackKind.Call */) {
+                                match = functionCalls.has(reference2.textSpan.start + reference2.textSpan.length);
+                            }
+                            if (match) {
+                                break;
+                            }
+                        }
+                        if (!match) {
+                            continue;
+                        }
+                    }
+                    let hasEffect = effect.sideEffectInfo?.isEffect;
+                    if (effect.bindingInfo) {
+                        const subs = findSubscribers(effect.bindingInfo.name, effect.bindingInfo.trackKinds, visited);
+                        result.push(...subs);
+                        hasEffect ||= subs.length > 0;
+                    }
+                    if (hasEffect) {
+                        result.push(effect);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    function findSignalByNamePosition(position) {
+        return signals.find(ref => ref.bindingInfo && ref.bindingInfo.name.getStart(sourceFile) <= position && ref.bindingInfo.name.getEnd() >= position);
+    }
+    function findEffectByEffectHandlerPosition(position) {
+        return signals.find(ref => ref.sideEffectInfo && ref.sideEffectInfo.handler.getStart(sourceFile) <= position && ref.sideEffectInfo.handler.getEnd() >= position);
+    }
+    function findEffectByDepsHandlerPosition(position) {
+        return signals.find(ref => ref.trackInfo && ref.trackInfo.depsHandler.getStart(sourceFile) <= position && ref.trackInfo.depsHandler.getEnd() >= position);
+    }
+}
+function collect(ts, sourceFile) {
+    const signals = [];
+    const dotValueAccesses = new Set();
+    const dotAnyAccesses = new Set();
+    const functionCalls = new Set();
+    sourceFile.forEachChild(function visit(node) {
+        if (ts.isVariableDeclaration(node)) {
+            if (node.initializer && ts.isCallExpression(node.initializer)) {
+                const call = node.initializer;
+                if (ts.isIdentifier(call.expression)) {
+                    const callName = call.expression.escapedText;
+                    if (callName === 'ref' || callName === 'shallowRef' || callName === 'toRef' || callName === 'useTemplateRef' || callName === 'defineModel') {
+                        signals.push({
+                            bindingInfo: {
+                                isRef: true,
+                                name: node.name,
+                                trackKinds: [0 /* TrackKind.AccessDotValue */],
+                            },
+                        });
+                    }
+                    else if (callName === 'reactive' || callName === 'shallowReactive' || callName === 'defineProps' || callName === 'withDefaults') {
+                        signals.push({
+                            bindingInfo: {
+                                isRef: true,
+                                name: node.name,
+                                trackKinds: [1 /* TrackKind.AccessAnyValue */],
+                            },
+                        });
+                    }
+                    // TODO: toRefs
+                }
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && node.body) {
+                signals.push({
+                    bindingInfo: {
+                        isRef: false,
+                        name: node.name,
+                        trackKinds: [2 /* TrackKind.Call */],
+                    },
+                    trackInfo: {
+                        depsHandler: node.body,
+                        needToUse: true,
+                    },
+                    sideEffectInfo: {
+                        isEffect: false,
+                        handler: node.body,
+                    },
+                });
+            }
+        }
+        else if (ts.isVariableStatement(node)) {
+            for (const declaration of node.declarationList.declarations) {
+                const name = declaration.name;
+                const callback = declaration.initializer;
+                if (callback && ts.isIdentifier(name) && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+                    signals.push({
+                        bindingInfo: {
+                            isRef: false,
+                            name: name,
+                            trackKinds: [2 /* TrackKind.Call */],
+                        },
+                        trackInfo: {
+                            depsHandler: callback,
+                            needToUse: true,
+                        },
+                        sideEffectInfo: {
+                            isEffect: false,
+                            handler: callback,
+                        },
+                    });
+                }
+            }
+        }
+        else if (ts.isParameter(node)) {
+            if (node.type && node.type && ts.isTypeReferenceNode(node.type)) {
+                const typeName = node.type.typeName.getText(sourceFile);
+                if (typeName.endsWith('Ref')) {
+                    signals.push({
+                        bindingInfo: {
+                            isRef: true,
+                            name: node.name,
+                            trackKinds: [0 /* TrackKind.AccessDotValue */],
+                        },
+                    });
+                }
+            }
+        }
+        else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const call = node;
+            const callName = node.expression.escapedText;
+            if ((callName === 'effect' || callName === 'watchEffect') && call.arguments.length) {
+                const callback = call.arguments[0];
+                if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+                    signals.push({
+                        trackInfo: {
+                            depsHandler: callback.body,
+                            needToUse: true,
+                        },
+                        sideEffectInfo: {
+                            isEffect: true,
+                            handler: callback.body,
+                        },
+                    });
+                }
+            }
+            if (callName === 'watch' && call.arguments.length >= 2) {
+                const depsCallback = call.arguments[0];
+                const effectCallback = call.arguments[1];
+                if (ts.isArrowFunction(effectCallback) || ts.isFunctionExpression(effectCallback)) {
+                    if (ts.isArrowFunction(depsCallback) || ts.isFunctionExpression(depsCallback)) {
+                        signals.push({
+                            trackInfo: {
+                                depsHandler: depsCallback.body,
+                                needToUse: true,
+                            },
+                            sideEffectInfo: {
+                                isEffect: true,
+                                handler: effectCallback.body,
+                            },
+                        });
+                    }
+                    else {
+                        signals.push({
+                            trackInfo: {
+                                depsHandler: depsCallback,
+                                needToUse: false,
+                            },
+                            sideEffectInfo: {
+                                isEffect: true,
+                                handler: effectCallback.body,
+                            }
+                        });
+                    }
+                }
+            }
+            else if ((0, language_core_1.hyphenateAttr)(callName).startsWith('use-')) {
+                signals.push({
+                    bindingInfo: ts.isVariableDeclaration(call.parent)
+                        ? {
+                            isRef: true,
+                            name: call.parent.name,
+                            trackKinds: [1 /* TrackKind.AccessAnyValue */, 2 /* TrackKind.Call */],
+                        }
+                        : undefined,
+                    trackInfo: {
+                        depsHandler: call,
+                        needToUse: false,
+                    },
+                });
+            }
+            else if ((callName === 'computed' || (0, language_core_1.hyphenateAttr)(callName).endsWith('-computed')) && call.arguments.length) {
+                const arg = call.arguments[0];
+                if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+                    signals.push({
+                        bindingInfo: ts.isVariableDeclaration(call.parent)
+                            ? {
+                                isRef: true,
+                                name: call.parent.name,
+                                trackKinds: [0 /* TrackKind.AccessDotValue */],
+                            }
+                            : undefined,
+                        trackInfo: {
+                            depsHandler: arg.body,
+                            needToUse: true,
+                        },
+                        sideEffectInfo: {
+                            isEffect: true,
+                            handler: arg.body,
+                        },
+                    });
+                }
+                else if (ts.isIdentifier(arg)) {
+                    signals.push({
+                        bindingInfo: ts.isVariableDeclaration(call.parent)
+                            ? {
+                                isRef: true,
+                                name: call.parent.name,
+                                trackKinds: [0 /* TrackKind.AccessDotValue */],
+                            }
+                            : undefined,
+                        trackInfo: {
+                            depsHandler: arg,
+                            needToUse: false,
+                        },
+                    });
+                }
+                else if (ts.isObjectLiteralExpression(arg)) {
+                    for (const prop of arg.properties) {
+                        if (prop.name?.getText(sourceFile) === 'get') {
+                            if (ts.isPropertyAssignment(prop)) {
+                                const callback = prop.initializer;
+                                if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+                                    signals.push({
+                                        bindingInfo: ts.isVariableDeclaration(call.parent)
+                                            ? {
+                                                isRef: true,
+                                                name: call.parent.name,
+                                                trackKinds: [0 /* TrackKind.AccessDotValue */],
+                                            }
+                                            : undefined,
+                                        trackInfo: {
+                                            depsHandler: callback.body,
+                                            needToUse: true,
+                                        },
+                                        sideEffectInfo: {
+                                            isEffect: true,
+                                            handler: callback.body,
+                                        },
+                                    });
+                                }
+                            }
+                            else if (ts.isMethodDeclaration(prop) && prop.body) {
+                                signals.push({
+                                    bindingInfo: ts.isVariableDeclaration(call.parent)
+                                        ? {
+                                            isRef: true,
+                                            name: call.parent.name,
+                                            trackKinds: [0 /* TrackKind.AccessDotValue */],
+                                        }
+                                        : undefined,
+                                    trackInfo: {
+                                        depsHandler: prop.body,
+                                        needToUse: true,
+                                    },
+                                    sideEffectInfo: {
+                                        isEffect: true,
+                                        handler: prop.body,
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        node.forEachChild(visit);
+    });
+    sourceFile.forEachChild(function visit(node) {
+        if (ts.isPropertyAccessExpression(node)) {
+            if (node.name.text === 'value') {
+                dotValueAccesses.add(node.expression.getEnd());
+                dotAnyAccesses.add(node.expression.getEnd());
+            }
+            else if (node.name.text !== '') {
+                dotAnyAccesses.add(node.expression.getEnd());
+            }
+        }
+        else if (ts.isElementAccessExpression(node)) {
+            dotAnyAccesses.add(node.expression.getEnd());
+        }
+        else if (ts.isCallExpression(node)) {
+            functionCalls.add(node.expression.getEnd());
+        }
+        node.forEachChild(visit);
+    });
+    return {
+        signals,
+        dotValueAccesses,
+        dotAnyAccesses,
+        functionCalls,
+    };
+}
+//# sourceMappingURL=reactionsAnalyze.js.map

package/lib/reactionsAnalyzeLS.d.ts

@@ -0,0 +1,5 @@
+import type * as ts from 'typescript';
+export declare function getLanguageService(ts: typeof import('typescript'), snapshot: ts.IScriptSnapshot, languageId: string): {
+    languageService: ts.LanguageService;
+    fileName: string;
+};

package/lib/reactionsAnalyzeLS.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLanguageService = getLanguageService;
+let currentProjectVersion = -1;
+let currentFileName = '';
+let currentSnapshot;
+let languageService;
+const host = {
+    getProjectVersion: () => currentProjectVersion.toString(),
+    getScriptFileNames: () => [currentFileName],
+    getScriptVersion: () => currentProjectVersion.toString(),
+    getScriptSnapshot: fileName => fileName === currentFileName ? currentSnapshot : undefined,
+    getCompilationSettings: () => ({}),
+    getCurrentDirectory: () => '',
+    getDefaultLibFileName: () => '',
+    readFile: () => undefined,
+    fileExists: fileName => fileName === currentFileName,
+};
+// TODO: share with volar-service-typescript
+function getLanguageService(ts, snapshot, languageId) {
+    if (currentSnapshot !== snapshot) {
+        currentSnapshot = snapshot;
+        currentFileName = '/tmp.' + (languageId === 'javascript' ? 'js' :
+            languageId === 'typescriptreact' ? 'tsx' :
+                languageId === 'javascriptreact' ? 'jsx' :
+                    'ts');
+        currentProjectVersion++;
+    }
+    languageService ??= ts.createLanguageService(host);
+    return {
+        languageService,
+        fileName: currentFileName,
+    };
+}
+//# sourceMappingURL=reactionsAnalyzeLS.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-server",
-	"version": "3.0.0-alpha.8",
+	"version": "3.0.0-beta.2",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -16,17 +16,18 @@
 		"directory": "packages/language-server"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.4.13",
-		"@volar/language-server": "~2.4.13",
-		"@volar/test-utils": "~2.4.13",
-		"@vue/language-core": "3.0.0-alpha.8",
-		"@vue/language-service": "3.0.0-alpha.8",
-		"@vue/typescript-plugin": "3.0.0-alpha.8",
-		"vscode-languageserver-protocol": "^3.17.5",
+		"@volar/language-server": "2.4.14",
+		"@vue/language-core": "3.0.0-beta.2",
+		"@vue/language-service": "3.0.0-beta.2",
+		"@vue/typescript-plugin": "3.0.0-beta.2",
 		"vscode-uri": "^3.0.8"
 	},
+	"peerDependencies": {
+		"typescript": "*"
+	},
 	"devDependencies": {
-		"@typescript/server-harness": "latest"
+		"@typescript/server-harness": "latest",
+		"@volar/test-utils": "2.4.14"
 	},
-	"gitHead": "d38cb93558fe8015c7ffe9ceacfdd3296e3692f6"
+	"gitHead": "ea40288f6fceebb65346732b6de5859c300cf1ee"
 }

package/lib/types.d.ts

@@ -1,8 +0,0 @@
-export type VueInitializationOptions = {
-    typescript: {
-        tsdk: string;
-        tsserverRequestCommand?: string;
-    };
-};
-export * from '@volar/language-server/lib/types';
-export * from '@vue/language-service/lib/types';

package/lib/types.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@volar/language-server/lib/types"), exports);
-__exportStar(require("@vue/language-service/lib/types"), exports);
-//# sourceMappingURL=types.js.map

package/node.d.ts

@@ -1 +0,0 @@
-export {};

package/node.js

@@ -1,149 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const simpleProject_1 = require("@volar/language-server/lib/project/simpleProject");
-const node_1 = require("@volar/language-server/node");
-const language_core_1 = require("@vue/language-core");
-const language_service_1 = require("@vue/language-service");
-const vscode_uri_1 = require("vscode-uri");
-const connection = (0, node_1.createConnection)();
-const server = (0, node_1.createServer)(connection);
-connection.listen();
-connection.onInitialize(params => {
-    const options = params.initializationOptions;
-    if (!options.typescript?.tsdk) {
-        throw new Error('typescript.tsdk is required');
-    }
-    if (!options.typescript?.tsserverRequestCommand) {
-        connection.console.warn('typescript.tsserverRequestCommand is required since >= 3.0 for complete TS features');
-    }
-    const { typescript: ts } = (0, node_1.loadTsdkByPath)(options.typescript.tsdk, params.locale);
-    const tsconfigProjects = (0, language_service_1.createUriMap)();
-    const file2ProjectInfo = new Map();
-    server.fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
-        for (const change of changes) {
-            const changeUri = vscode_uri_1.URI.parse(change.uri);
-            if (tsconfigProjects.has(changeUri)) {
-                tsconfigProjects.get(changeUri).dispose();
-                tsconfigProjects.delete(changeUri);
-                file2ProjectInfo.clear();
-            }
-        }
-    });
-    let simpleLs;
-    return server.initialize(params, {
-        setup() { },
-        async getLanguageService(uri) {
-            if (uri.scheme === 'file' && options.typescript.tsserverRequestCommand) {
-                const fileName = uri.fsPath.replace(/\\/g, '/');
-                let projectInfoPromise = file2ProjectInfo.get(fileName);
-                if (!projectInfoPromise) {
-                    projectInfoPromise = sendTsRequest(ts.server.protocol.CommandTypes.ProjectInfo, {
-                        file: fileName,
-                        needFileNameList: false,
-                    });
-                    file2ProjectInfo.set(fileName, projectInfoPromise);
-                }
-                const projectInfo = await projectInfoPromise;
-                if (projectInfo) {
-                    const { configFileName } = projectInfo;
-                    let ls = tsconfigProjects.get(vscode_uri_1.URI.file(configFileName));
-                    if (!ls) {
-                        ls = createLs(server, configFileName);
-                        tsconfigProjects.set(vscode_uri_1.URI.file(configFileName), ls);
-                    }
-                    return ls;
-                }
-            }
-            return simpleLs ??= createLs(server, undefined);
-        },
-        getExistingLanguageServices() {
-            return Promise.all([
-                ...tsconfigProjects.values(),
-                simpleLs,
-            ].filter(promise => !!promise));
-        },
-        reload() {
-            for (const ls of [
-                ...tsconfigProjects.values(),
-                simpleLs,
-            ]) {
-                ls?.dispose();
-            }
-            tsconfigProjects.clear();
-            simpleLs = undefined;
-        },
-    }, (0, language_service_1.getHybridModeLanguageServicePlugins)(ts, options.typescript.tsserverRequestCommand ? {
-        collectExtractProps(...args) {
-            return sendTsRequest('vue:collectExtractProps', args);
-        },
-        getComponentDirectives(...args) {
-            return sendTsRequest('vue:getComponentDirectives', args);
-        },
-        getComponentEvents(...args) {
-            return sendTsRequest('vue:getComponentEvents', args);
-        },
-        getComponentNames(...args) {
-            return sendTsRequest('vue:getComponentNames', args);
-        },
-        getComponentProps(...args) {
-            return sendTsRequest('vue:getComponentProps', args);
-        },
-        getElementAttrs(...args) {
-            return sendTsRequest('vue:getElementAttrs', args);
-        },
-        getElementNames(...args) {
-            return sendTsRequest('vue:getElementNames', args);
-        },
-        getImportPathForFile(...args) {
-            return sendTsRequest('vue:getImportPathForFile', args);
-        },
-        getPropertiesAtLocation(...args) {
-            return sendTsRequest('vue:getPropertiesAtLocation', args);
-        },
-        getDocumentHighlights(fileName, position) {
-            return sendTsRequest('documentHighlights-full', // internal command
-            {
-                file: fileName,
-                ...{ position },
-                filesToSearch: [fileName],
-            });
-        },
-        async getQuickInfoAtPosition(fileName, { line, character }) {
-            const result = await sendTsRequest(ts.server.protocol.CommandTypes.Quickinfo, {
-                file: fileName,
-                line: line + 1,
-                offset: character + 1,
-            });
-            return ts.displayPartsToString(result?.displayParts ?? []);
-        },
-    } : undefined));
-    function sendTsRequest(command, args) {
-        return connection.sendRequest(options.typescript.tsserverRequestCommand, [command, args]);
-    }
-    function createLs(server, tsconfig) {
-        const commonLine = tsconfig
-            ? (0, language_core_1.createParsedCommandLine)(ts, ts.sys, tsconfig)
-            : {
-                options: ts.getDefaultCompilerOptions(),
-                vueOptions: (0, language_core_1.getDefaultCompilerOptions)(),
-            };
-        const language = (0, language_core_1.createLanguage)([
-            {
-                getLanguageId: uri => server.documents.get(uri)?.languageId,
-            },
-            (0, language_core_1.createVueLanguagePlugin)(ts, commonLine.options, commonLine.vueOptions, uri => uri.fsPath.replace(/\\/g, '/')),
-        ], (0, language_service_1.createUriMap)(), uri => {
-            const document = server.documents.get(uri);
-            if (document) {
-                language.scripts.set(uri, document.getSnapshot(), document.languageId);
-            }
-            else {
-                language.scripts.delete(uri);
-            }
-        });
-        return (0, language_service_1.createLanguageService)(language, server.languageServicePlugins, (0, simpleProject_1.createLanguageServiceEnvironment)(server, [...server.workspaceFolders.all]), { vue: { compilerOptions: commonLine.vueOptions } });
-    }
-});
-connection.onInitialized(server.initialized);
-connection.onShutdown(server.shutdown);
-//# sourceMappingURL=node.js.map

package/protocol.d.ts

@@ -1 +0,0 @@
-export * from '@volar/language-server/protocol';

package/protocol.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@volar/language-server/protocol"), exports);
-//# sourceMappingURL=protocol.js.map