@vue/typescript-plugin 2.2.10 → 3.0.0-alpha.10

package/index.d.ts

@@ -1,3 +1,3 @@
 import type * as ts from 'typescript';
-declare const plugin: ts.server.PluginModuleFactory;
-export = plugin;
+declare const _default: ts.server.PluginModuleFactory;
+export = _default;

package/index.js

@@ -2,21 +2,26 @@
 const createLanguageServicePlugin_1 = require("@volar/typescript/lib/quickstart/createLanguageServicePlugin");
 const vue = require("@vue/language-core");
 const common_1 = require("./lib/common");
-const server_1 = require("./lib/server");
+const collectExtractProps_1 = require("./lib/requests/collectExtractProps");
+const getComponentDirectives_1 = require("./lib/requests/getComponentDirectives");
+const getComponentEvents_1 = require("./lib/requests/getComponentEvents");
+const getComponentNames_1 = require("./lib/requests/getComponentNames");
+const getComponentProps_1 = require("./lib/requests/getComponentProps");
+const getElementAttrs_1 = require("./lib/requests/getElementAttrs");
+const getElementNames_1 = require("./lib/requests/getElementNames");
+const getImportPathForFile_1 = require("./lib/requests/getImportPathForFile");
+const getPropertiesAtLocation_1 = require("./lib/requests/getPropertiesAtLocation");
 const windowsPathReg = /\\/g;
-const vueCompilerOptions = new WeakMap();
-const plugin = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)((ts, info) => {
+const project2Service = new WeakMap();
+module.exports = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)((ts, info) => {
     const vueOptions = getVueCompilerOptions();
     const languagePlugin = vue.createVueLanguagePlugin(ts, info.languageServiceHost.getCompilationSettings(), vueOptions, id => id);
-    vueCompilerOptions.set(info.project, vueOptions);
+    addVueCommands();
     return {
         languagePlugins: [languagePlugin],
         setup: language => {
+            project2Service.set(info.project, [language, info.languageServiceHost, info.languageService]);
             info.languageService = (0, common_1.proxyLanguageServiceForVue)(ts, language, info.languageService, vueOptions, fileName => fileName);
-            if (info.project.projectKind === ts.server.ProjectKind.Configured
-                || info.project.projectKind === ts.server.ProjectKind.Inferred) {
-                (0, server_1.startNamedPipeServer)(ts, info, language, info.project.projectKind);
-            }
             // #3963
             const timer = setInterval(() => {
                 if (info.project['program']) {
@@ -35,6 +40,88 @@ const plugin = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)((t
             return vue.createParsedCommandLineByJson(ts, ts.sys, info.languageServiceHost.getCurrentDirectory(), {}).vueOptions;
         }
     }
+    // https://github.com/JetBrains/intellij-plugins/blob/6435723ad88fa296b41144162ebe3b8513f4949b/Angular/src-js/angular-service/src/index.ts#L69
+    function addVueCommands() {
+        const projectService = info.project.projectService;
+        projectService.logger.info("Vue: called handler processing " + info.project.projectKind);
+        const session = info.session;
+        if (session == undefined) {
+            projectService.logger.info("Vue: there is no session in info.");
+            return;
+        }
+        if (session.addProtocolHandler == undefined) {
+            // addProtocolHandler was introduced in TS 4.4 or 4.5 in 2021, see https://github.com/microsoft/TypeScript/issues/43893
+            projectService.logger.info("Vue: there is no addProtocolHandler method.");
+            return;
+        }
+        if (session.vueCommandsAdded) {
+            return;
+        }
+        session.vueCommandsAdded = true;
+        session.addProtocolHandler('vue:collectExtractProps', ({ arguments: args }) => {
+            return {
+                response: collectExtractProps_1.collectExtractProps.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getImportPathForFile', ({ arguments: args }) => {
+            return {
+                response: getImportPathForFile_1.getImportPathForFile.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getPropertiesAtLocation', ({ arguments: args }) => {
+            return {
+                response: getPropertiesAtLocation_1.getPropertiesAtLocation.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getComponentNames', ({ arguments: args }) => {
+            return {
+                response: getComponentNames_1.getComponentNames.apply(getRequestContext(args[0]), args) ?? [],
+            };
+        });
+        session.addProtocolHandler('vue:getComponentProps', ({ arguments: args }) => {
+            return {
+                response: getComponentProps_1.getComponentProps.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getComponentEvents', ({ arguments: args }) => {
+            return {
+                response: getComponentEvents_1.getComponentEvents.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getComponentDirectives', ({ arguments: args }) => {
+            return {
+                response: getComponentDirectives_1.getComponentDirectives.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getElementAttrs', ({ arguments: args }) => {
+            return {
+                response: getElementAttrs_1.getElementAttrs.apply(getRequestContext(args[0]), args),
+            };
+        });
+        session.addProtocolHandler('vue:getElementNames', ({ arguments: args }) => {
+            return {
+                response: getElementNames_1.getElementNames.apply(getRequestContext(args[0]), args),
+            };
+        });
+        projectService.logger.info('Vue specific commands are successfully added.');
+    }
+    function getRequestContext(fileName) {
+        const fileAndProject = info.session.getFileAndProject({
+            file: fileName,
+            projectFileName: undefined,
+        });
+        const service = project2Service.get(fileAndProject.project);
+        if (!service) {
+            throw 'No RequestContext';
+        }
+        return {
+            typescript: ts,
+            languageService: service[2],
+            languageServiceHost: service[1],
+            language: service[0],
+            isTsPlugin: true,
+            getFileId: (fileName) => fileName,
+        };
+    }
 });
-module.exports = plugin;
 //# sourceMappingURL=index.js.map

package/lib/common.d.ts

@@ -1,5 +1,3 @@
-import { Language, VueCompilerOptions, VueVirtualCode } from '@vue/language-core';
+import { type Language, type VueCompilerOptions } from '@vue/language-core';
 import type * as ts from 'typescript';
-import type { RequestContext } from './requests/types';
 export declare function proxyLanguageServiceForVue<T>(ts: typeof import('typescript'), language: Language<T>, languageService: ts.LanguageService, vueOptions: VueCompilerOptions, asScriptId: (fileName: string) => T): ts.LanguageService;
-export declare function getComponentSpans(this: Pick<RequestContext, 'typescript' | 'languageService'>, vueCode: VueVirtualCode, template: NonNullable<VueVirtualCode['_sfc']['template']>, spanTemplateRange: ts.TextSpan): ts.TextSpan[];

package/lib/common.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.proxyLanguageServiceForVue = proxyLanguageServiceForVue;
-exports.getComponentSpans = getComponentSpans;
 const language_core_1 = require("@vue/language-core");
 const shared_1 = require("@vue/shared");
 const getComponentNames_1 = require("./requests/getComponentNames");
-const getElementAttrs_1 = require("./requests/getElementAttrs");
+const getElementNames_1 = require("./requests/getElementNames");
 const windowsPathReg = /\\/g;
 function proxyLanguageServiceForVue(ts, language, languageService, vueOptions, asScriptId) {
     const proxyCache = new Map();
@@ -152,6 +151,15 @@ function getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, as
         }
         const definitions = new Set(result.definitions);
         const skippedDefinitions = [];
+        // #5275
+        if (result.definitions.length >= 2) {
+            for (const definition of result.definitions) {
+                if (root.sfc.content[definition.textSpan.start - 1] === '@'
+                    || root.sfc.content.slice(definition.textSpan.start - 5, definition.textSpan.start) === 'v-on:') {
+                    skippedDefinitions.push(definition);
+                }
+            }
+        }
         for (const definition of result.definitions) {
             if (vueOptions.extensions.some(ext => definition.fileName.endsWith(ext))) {
                 continue;
@@ -264,7 +272,7 @@ function getComponentSpans(vueCode, template, spanTemplateRange) {
     const { typescript: ts, languageService } = this;
     const result = [];
     const validComponentNames = (0, getComponentNames_1._getComponentNames)(ts, languageService, vueCode);
-    const elements = new Set((0, getElementAttrs_1._getElementNames)(ts, languageService, vueCode));
+    const elements = new Set((0, getElementNames_1._getElementNames)(ts, languageService, vueCode));
     const components = new Set([
         ...validComponentNames,
         ...validComponentNames.map(language_core_1.hyphenateTag),

package/lib/requests/getComponentProps.d.ts

@@ -3,6 +3,7 @@ export interface ComponentPropInfo {
     name: string;
     required?: boolean;
     deprecated?: boolean;
+    isAttribute?: boolean;
     commentMarkdown?: string;
     values?: string[];
 }

package/lib/requests/getComponentProps.js

@@ -10,8 +10,6 @@ function getComponentProps(fileName, tag) {
         return;
     }
     const vueCode = volarFile.generated.root;
-    const program = languageService.getProgram();
-    const checker = program.getTypeChecker();
     const components = (0, utils_1.getVariableType)(ts, languageService, vueCode, '__VLS_components');
     if (!components) {
         return [];
@@ -21,21 +19,15 @@ function getComponentProps(fileName, tag) {
         return [];
     }
     const result = new Map();
+    const program = languageService.getProgram();
+    const checker = program.getTypeChecker();
     for (const sig of componentType.getCallSignatures()) {
         const propParam = sig.parameters[0];
         if (propParam) {
             const propsType = checker.getTypeOfSymbolAtLocation(propParam, components.node);
             const props = propsType.getProperties();
             for (const prop of props) {
-                const name = prop.name;
-                const required = !(prop.flags & ts.SymbolFlags.Optional) || undefined;
-                const { content: commentMarkdown, deprecated } = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags());
-                result.set(name, {
-                    name,
-                    required,
-                    deprecated,
-                    commentMarkdown
-                });
+                handlePropSymbol(prop);
             }
         }
     }
@@ -46,22 +38,51 @@ function getComponentProps(fileName, tag) {
             const propsType = checker.getTypeOfSymbolAtLocation(propsSymbol, components.node);
             const props = propsType.getProperties();
             for (const prop of props) {
-                if (prop.flags & ts.SymbolFlags.Method) { // #2443
-                    continue;
-                }
-                const name = prop.name;
-                const required = !(prop.flags & ts.SymbolFlags.Optional) || undefined;
-                const { content: commentMarkdown, deprecated } = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags());
-                result.set(name, {
-                    name,
-                    required,
-                    deprecated,
-                    commentMarkdown
-                });
+                handlePropSymbol(prop);
             }
         }
     }
     return [...result.values()];
+    function handlePropSymbol(prop) {
+        if (prop.flags & ts.SymbolFlags.Method) { // #2443
+            return;
+        }
+        const name = prop.name;
+        const required = !(prop.flags & ts.SymbolFlags.Optional) || undefined;
+        const { content: commentMarkdown, deprecated, } = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags());
+        const values = [];
+        const type = checker.getTypeOfSymbol(prop);
+        const subTypes = type.types;
+        if (subTypes) {
+            for (const subType of subTypes) {
+                const value = subType.value;
+                if (value) {
+                    values.push(value);
+                }
+            }
+        }
+        let isAttribute;
+        for (const { parent } of checker.getRootSymbols(prop).flatMap(root => root.declarations ?? [])) {
+            if (!ts.isInterfaceDeclaration(parent)) {
+                continue;
+            }
+            const { text } = parent.name;
+            if (text.endsWith('HTMLAttributes')
+                || text === 'AriaAttributes'
+                || text === 'SVGAttributes') {
+                isAttribute = true;
+                break;
+            }
+        }
+        result.set(name, {
+            name,
+            required,
+            deprecated,
+            isAttribute,
+            commentMarkdown,
+            values,
+        });
+    }
 }
 function generateCommentMarkdown(parts, jsDocTags) {
     const parsedComment = _symbolDisplayPartsToMarkdown(parts);

package/lib/requests/getElementAttrs.d.ts

@@ -1,5 +1,2 @@
-import { VueVirtualCode } from '@vue/language-core';
-import type * as ts from 'typescript';
 import type { RequestContext } from './types';
 export declare function getElementAttrs(this: RequestContext, fileName: string, tagName: string): string[] | undefined;
-export declare function _getElementNames(ts: typeof import('typescript'), tsLs: ts.LanguageService, vueCode: VueVirtualCode): string[];

package/lib/requests/getElementAttrs.js

@@ -1,45 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getElementAttrs = getElementAttrs;
-exports._getElementNames = _getElementNames;
 const language_core_1 = require("@vue/language-core");
+const utils_1 = require("./utils");
 function getElementAttrs(fileName, tagName) {
     const { typescript: ts, language, languageService, getFileId } = this;
     const volarFile = language.scripts.get(getFileId(fileName));
     if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
         return;
     }
+    const vueCode = volarFile.generated.root;
     const program = languageService.getProgram();
-    const tsSourceFile = program.getSourceFile(fileName);
-    if (tsSourceFile) {
-        const checker = program.getTypeChecker();
-        const typeNode = tsSourceFile.statements
-            .filter(ts.isTypeAliasDeclaration)
-            .find(node => node.name.getText() === '__VLS_IntrinsicElementsCompletion');
-        if (typeNode) {
-            const type = checker.getTypeFromTypeNode(typeNode.type);
-            const el = type.getProperty(tagName);
-            if (el) {
-                const attrs = checker.getTypeOfSymbolAtLocation(el, typeNode).getProperties();
-                return attrs.map(c => c.name);
-            }
-        }
+    const checker = program.getTypeChecker();
+    const elements = (0, utils_1.getVariableType)(ts, languageService, vueCode, '__VLS_elements');
+    if (!elements) {
+        return [];
     }
-    return [];
-}
-function _getElementNames(ts, tsLs, vueCode) {
-    const program = tsLs.getProgram();
-    const tsSourceFile = program.getSourceFile(vueCode.fileName);
-    if (tsSourceFile) {
-        const checker = program.getTypeChecker();
-        const typeNode = tsSourceFile.statements
-            .filter(ts.isTypeAliasDeclaration)
-            .find(node => node.name.getText() === '__VLS_IntrinsicElementsCompletion');
-        if (typeNode) {
-            const type = checker.getTypeFromTypeNode(typeNode.type);
-            return type.getProperties().map(c => c.name);
-        }
+    const elementType = elements.type.getProperty(tagName);
+    if (!elementType) {
+        return [];
     }
-    return [];
+    const attrs = checker.getTypeOfSymbol(elementType).getProperties();
+    return attrs.map(c => c.name);
 }
 //# sourceMappingURL=getElementAttrs.js.map

package/lib/requests/getFileReferences.d.ts

@@ -0,0 +1,9 @@
+import type * as ts from "typescript";
+import type { RequestContext } from "./types";
+export declare function getFileReferences(this: RequestContext, fileName: string): {
+    fileName: string;
+    range: {
+        start: ts.LineAndCharacter;
+        end: ts.LineAndCharacter;
+    };
+}[];

package/lib/requests/getFileReferences.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileReferences = getFileReferences;
+function getFileReferences(fileName) {
+    const { typescript: ts, languageService } = this;
+    const program = languageService.getProgram();
+    const result = languageService.getFileReferences(fileName);
+    const references = new Set(result);
+    const skippedReferences = [];
+    for (const reference of result) {
+        if (reference.fileName.endsWith('.vue')) {
+            continue;
+        }
+        const sourceFile = program.getSourceFile(reference.fileName);
+        if (!sourceFile) {
+            continue;
+        }
+        visit(sourceFile, reference, sourceFile);
+    }
+    for (const reference of skippedReferences) {
+        references.delete(reference);
+    }
+    return [...references].map(({ fileName, textSpan }) => {
+        const sourceFile = program.getSourceFile(fileName);
+        const start = sourceFile.getLineAndCharacterOfPosition(textSpan.start);
+        const end = sourceFile.getLineAndCharacterOfPosition(textSpan.start + textSpan.length);
+        return {
+            fileName,
+            range: {
+                start,
+                end,
+            },
+        };
+    });
+    function visit(node, reference, sourceFile) {
+        if (ts.isPropertySignature(node) && node.type) {
+            proxy(node.name, node.type, reference, sourceFile);
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.type && !node.initializer) {
+            proxy(node.name, node.type, reference, sourceFile, true);
+        }
+        else {
+            ts.forEachChild(node, child => visit(child, reference, sourceFile));
+        }
+    }
+    function proxy(name, type, reference, sourceFile, skip = false) {
+        const { textSpan, fileName } = reference;
+        const start = type.getStart(sourceFile);
+        const end = type.getEnd();
+        if (start > textSpan.start || end < textSpan.start + textSpan.length) {
+            return;
+        }
+        if (skip) {
+            skippedReferences.push(reference);
+            return;
+        }
+        const pos = name.getStart(sourceFile);
+        const res = languageService.findReferences(fileName, pos) ?? [];
+        const items = res.flatMap(({ references }) => references);
+        if (items.length) {
+            for (const reference of items) {
+                if (reference.isDefinition) {
+                    continue;
+                }
+                references.add(reference);
+            }
+            skippedReferences.push(reference);
+        }
+    }
+}
+//# sourceMappingURL=getFileReferences.js.map

package/lib/requests/getPropertiesAtLocation.js

@@ -1,4 +1,5 @@
 "use strict";
+/// <reference types="@volar/typescript" />
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPropertiesAtLocation = getPropertiesAtLocation;
 const language_core_1 = require("@vue/language-core");

package/lib/requests/utils.js

@@ -4,7 +4,7 @@ exports.getComponentType = getComponentType;
 exports.getSelfComponentName = getSelfComponentName;
 exports.getVariableType = getVariableType;
 const shared_1 = require("@vue/shared");
-const path = require("node:path");
+const path = require("path-browserify");
 function getComponentType(ts, languageService, vueCode, components, fileName, tag) {
     const program = languageService.getProgram();
     const checker = program.getTypeChecker();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "2.2.10",
+	"version": "3.0.0-alpha.10",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,12 +13,14 @@
 		"directory": "packages/typescript-plugin"
 	},
 	"dependencies": {
-		"@volar/typescript": "~2.4.11",
-		"@vue/language-core": "2.2.10",
-		"@vue/shared": "^3.5.0"
+		"@volar/typescript": "~2.4.13",
+		"@vue/language-core": "3.0.0-alpha.10",
+		"@vue/shared": "^3.5.0",
+		"path-browserify": "^1.0.1"
 	},
 	"devDependencies": {
-		"@types/node": "^22.10.4"
+		"@types/node": "^22.10.4",
+		"@types/path-browserify": "^1.0.1"
 	},
-	"gitHead": "0422c03ffa4958431c9cd3cd19ae51f726c30b07"
+	"gitHead": "28308b4f76cc80c7632f39ae7e0944f1889661a2"
 }

package/lib/commands.d.ts

@@ -1,3 +0,0 @@
-import { type Language } from '@vue/language-core';
-import type * as ts from 'typescript';
-export declare function addVueCommands(ts: typeof import('typescript'), info: ts.server.PluginCreateInfo, project2Service: Map<ts.server.Project, [Language, ts.LanguageServiceHost, ts.LanguageService]>): void;

package/lib/commands.js

@@ -1,136 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addVueCommands = addVueCommands;
-const language_core_1 = require("@vue/language-core");
-const collectExtractProps_1 = require("./requests/collectExtractProps");
-const getComponentDirectives_1 = require("./requests/getComponentDirectives");
-const getComponentEvents_1 = require("./requests/getComponentEvents");
-const getComponentNames_1 = require("./requests/getComponentNames");
-const getComponentProps_1 = require("./requests/getComponentProps");
-const getElementAttrs_1 = require("./requests/getElementAttrs");
-const getElementNames_1 = require("./requests/getElementNames");
-const getImportPathForFile_1 = require("./requests/getImportPathForFile");
-const getPropertiesAtLocation_1 = require("./requests/getPropertiesAtLocation");
-// https://github.com/JetBrains/intellij-plugins/blob/6435723ad88fa296b41144162ebe3b8513f4949b/Angular/src-js/angular-service/src/index.ts#L69
-function addVueCommands(ts, info, project2Service) {
-    const projectService = info.project.projectService;
-    projectService.logger.info("Vue: called handler processing " + info.project.projectKind);
-    const session = info.session;
-    if (session == undefined) {
-        projectService.logger.info("Vue: there is no session in info.");
-        return;
-    }
-    if (session.addProtocolHandler == undefined) {
-        // addProtocolHandler was introduced in TS 4.4 or 4.5 in 2021, see https://github.com/microsoft/TypeScript/issues/43893
-        projectService.logger.info("Vue: there is no addProtocolHandler method.");
-        return;
-    }
-    if (session.vueCommandsAdded) {
-        return;
-    }
-    session.vueCommandsAdded = true;
-    const isCaseSensitive = info.languageServiceHost.useCaseSensitiveFileNames?.() ?? false;
-    let lastProjectVersion;
-    let scriptInfos = new language_core_1.FileMap(isCaseSensitive);
-    session.addProtocolHandler('vue:isProjectUpdated', () => {
-        const projectVersion = info.project.getProjectVersion();
-        if (projectVersion === lastProjectVersion) {
-            return { response: 'no' };
-        }
-        lastProjectVersion = projectVersion;
-        const [, [language, languageServiceHost]] = [...project2Service].find(([project]) => project.projectKind === ts.server.ProjectKind.Configured);
-        const fileNames = languageServiceHost.getScriptFileNames();
-        const infos = new language_core_1.FileMap(isCaseSensitive);
-        let isAnyScriptVersionChanged = false;
-        let isAnyScriptSnapshotChanged = false;
-        for (const file of fileNames) {
-            const scriptVersion = languageServiceHost.getScriptVersion(file);
-            const scriptInfo = scriptInfos.get(file) ?? { version: "" };
-            infos.set(file, scriptInfo);
-            if (scriptInfo.version === scriptVersion) {
-                continue;
-            }
-            scriptInfo.version = scriptVersion;
-            isAnyScriptVersionChanged = true;
-            const volarFile = language.scripts.get(file);
-            const root = volarFile?.generated?.root;
-            const serviceScript = volarFile?.generated?.languagePlugin.typescript?.getServiceScript(root);
-            if (!serviceScript) {
-                isAnyScriptSnapshotChanged = true;
-                continue;
-            }
-            const { snapshot } = serviceScript.code;
-            if (scriptInfo.snapshot !== snapshot) {
-                scriptInfo.snapshot = snapshot;
-                isAnyScriptSnapshotChanged = true;
-            }
-        }
-        scriptInfos = infos;
-        return { response: isAnyScriptSnapshotChanged || !isAnyScriptVersionChanged ? 'yes' : 'no' };
-    });
-    session.addProtocolHandler('vue:collectExtractProps', ({ arguments: args }) => {
-        return {
-            response: collectExtractProps_1.collectExtractProps.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getImportPathForFile', ({ arguments: args }) => {
-        return {
-            response: getImportPathForFile_1.getImportPathForFile.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getPropertiesAtLocation', ({ arguments: args }) => {
-        return {
-            response: getPropertiesAtLocation_1.getPropertiesAtLocation.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getComponentNames', ({ arguments: args }) => {
-        return {
-            response: getComponentNames_1.getComponentNames.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getComponentProps', ({ arguments: args }) => {
-        return {
-            response: getComponentProps_1.getComponentProps.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getComponentEvents', ({ arguments: args }) => {
-        return {
-            response: getComponentEvents_1.getComponentEvents.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getComponentDirectives', ({ arguments: args }) => {
-        return {
-            response: getComponentDirectives_1.getComponentDirectives.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getElementAttrs', ({ arguments: args }) => {
-        return {
-            response: getElementAttrs_1.getElementAttrs.apply(getRequestContext(args[0]), args),
-        };
-    });
-    session.addProtocolHandler('vue:getElementNames', ({ arguments: args }) => {
-        return {
-            response: getElementNames_1.getElementNames.apply(getRequestContext(args[0]), args),
-        };
-    });
-    projectService.logger.info('Vue specific commands are successfully added.');
-    function getRequestContext(fileName) {
-        const fileAndProject = info.session.getFileAndProject({
-            file: fileName,
-            projectFileName: undefined,
-        });
-        const service = project2Service.get(fileAndProject.project);
-        if (!service) {
-            throw 'No RequestContext';
-        }
-        return {
-            typescript: ts,
-            languageService: service[2],
-            languageServiceHost: service[1],
-            language: service[0],
-            isTsPlugin: true,
-            getFileId: (fileName) => fileName,
-        };
-    }
-}
-//# sourceMappingURL=commands.js.map

package/lib/proxy.d.ts

@@ -1,3 +0,0 @@
-import { Language, VueCompilerOptions } from '@vue/language-core';
-import type * as ts from 'typescript';
-export declare function proxyLanguageServiceForVue<T>(ts: typeof import('typescript'), language: Language<T>, languageService: ts.LanguageService, vueOptions: VueCompilerOptions, asScriptId: (fileName: string) => T): ts.LanguageService;

package/lib/proxy.js

@@ -1,305 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.proxyLanguageServiceForVue = proxyLanguageServiceForVue;
-const language_core_1 = require("@vue/language-core");
-const shared_1 = require("@vue/shared");
-const getComponentNames_1 = require("./requests/getComponentNames");
-const getElementNames_1 = require("./requests/getElementNames");
-const windowsPathReg = /\\/g;
-function proxyLanguageServiceForVue(ts, language, languageService, vueOptions, asScriptId) {
-    const proxyCache = new Map();
-    const getProxyMethod = (target, p) => {
-        switch (p) {
-            case 'getCompletionsAtPosition': return getCompletionsAtPosition(vueOptions, target[p]);
-            case 'getCompletionEntryDetails': return getCompletionEntryDetails(language, asScriptId, target[p]);
-            case 'getCodeFixesAtPosition': return getCodeFixesAtPosition(target[p]);
-            case 'getDefinitionAndBoundSpan': return getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, asScriptId, target[p]);
-            case 'getQuickInfoAtPosition': return getQuickInfoAtPosition(ts, target, target[p]);
-            // TS plugin only
-            case 'getEncodedSemanticClassifications': return getEncodedSemanticClassifications(ts, language, target, asScriptId, target[p]);
-        }
-    };
-    return new Proxy(languageService, {
-        get(target, p, receiver) {
-            if (getProxyMethod) {
-                if (!proxyCache.has(p)) {
-                    proxyCache.set(p, getProxyMethod(target, p));
-                }
-                const proxyMethod = proxyCache.get(p);
-                if (proxyMethod) {
-                    return proxyMethod;
-                }
-            }
-            return Reflect.get(target, p, receiver);
-        },
-        set(target, p, value, receiver) {
-            return Reflect.set(target, p, value, receiver);
-        },
-    });
-}
-function getCompletionsAtPosition(vueOptions, getCompletionsAtPosition) {
-    return (filePath, position, options, formattingSettings) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const result = getCompletionsAtPosition(fileName, position, options, formattingSettings);
-        if (result) {
-            // filter __VLS_
-            result.entries = result.entries.filter(entry => !entry.name.includes('__VLS_')
-                && !entry.labelDetails?.description?.includes('__VLS_'));
-            // modify label
-            for (const item of result.entries) {
-                if (item.source) {
-                    const originalName = item.name;
-                    for (const vueExt of vueOptions.extensions) {
-                        const suffix = (0, shared_1.capitalize)(vueExt.slice(1)); // .vue -> Vue
-                        if (item.source.endsWith(vueExt) && item.name.endsWith(suffix)) {
-                            item.name = (0, shared_1.capitalize)(item.name.slice(0, -suffix.length));
-                            if (item.insertText) {
-                                // #2286
-                                item.insertText = item.insertText.replace(`${suffix}$1`, '$1');
-                            }
-                            if (item.data) {
-                                // @ts-expect-error
-                                item.data.__isComponentAutoImport = {
-                                    ext: vueExt,
-                                    suffix,
-                                    originalName,
-                                    newName: item.insertText,
-                                };
-                            }
-                            break;
-                        }
-                    }
-                    if (item.data) {
-                        // @ts-expect-error
-                        item.data.__isAutoImport = {
-                            fileName,
-                        };
-                    }
-                }
-            }
-        }
-        return result;
-    };
-}
-function getCompletionEntryDetails(language, asScriptId, getCompletionEntryDetails) {
-    return (...args) => {
-        const details = getCompletionEntryDetails(...args);
-        // modify import statement
-        // @ts-expect-error
-        if (args[6]?.__isComponentAutoImport) {
-            // @ts-expect-error
-            const { ext, suffix, originalName, newName } = args[6]?.__isComponentAutoImport;
-            for (const codeAction of details?.codeActions ?? []) {
-                for (const change of codeAction.changes) {
-                    for (const textChange of change.textChanges) {
-                        textChange.newText = textChange.newText.replace('import ' + originalName + ' from ', 'import ' + newName + ' from ');
-                    }
-                }
-            }
-        }
-        // @ts-expect-error
-        if (args[6]?.__isAutoImport) {
-            // @ts-expect-error
-            const { fileName } = args[6]?.__isAutoImport;
-            const sourceScript = language.scripts.get(asScriptId(fileName));
-            if (sourceScript?.generated?.root instanceof language_core_1.VueVirtualCode) {
-                const sfc = sourceScript.generated.root.vueSfc;
-                if (!sfc?.descriptor.script && !sfc?.descriptor.scriptSetup) {
-                    for (const codeAction of details?.codeActions ?? []) {
-                        for (const change of codeAction.changes) {
-                            for (const textChange of change.textChanges) {
-                                textChange.newText = `<script setup lang="ts">${textChange.newText}</script>\n\n`;
-                                break;
-                            }
-                            break;
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-        return details;
-    };
-}
-function getCodeFixesAtPosition(getCodeFixesAtPosition) {
-    return (...args) => {
-        let result = getCodeFixesAtPosition(...args);
-        // filter __VLS_
-        result = result.filter(entry => !entry.description.includes('__VLS_'));
-        return result;
-    };
-}
-function getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, asScriptId, getDefinitionAndBoundSpan) {
-    return (fileName, position) => {
-        const result = getDefinitionAndBoundSpan(fileName, position);
-        if (!result?.definitions?.length) {
-            return result;
-        }
-        const program = languageService.getProgram();
-        const sourceScript = language.scripts.get(asScriptId(fileName));
-        if (!sourceScript?.generated) {
-            return result;
-        }
-        const root = sourceScript.generated.root;
-        if (!(root instanceof language_core_1.VueVirtualCode)) {
-            return result;
-        }
-        if (!root.sfc.template
-            || position < root.sfc.template.startTagEnd
-            || position > root.sfc.template.endTagStart) {
-            return result;
-        }
-        const definitions = new Set(result.definitions);
-        const skippedDefinitions = [];
-        // #5275
-        if (result.definitions.length >= 2) {
-            for (const definition of result.definitions) {
-                if (root.sfc.content[definition.textSpan.start - 1] === '@'
-                    || root.sfc.content.slice(definition.textSpan.start - 5, definition.textSpan.start) === 'v-on:') {
-                    skippedDefinitions.push(definition);
-                }
-            }
-        }
-        for (const definition of result.definitions) {
-            if (vueOptions.extensions.some(ext => definition.fileName.endsWith(ext))) {
-                continue;
-            }
-            const sourceFile = program.getSourceFile(definition.fileName);
-            if (!sourceFile) {
-                continue;
-            }
-            visit(sourceFile, definition, sourceFile);
-        }
-        for (const definition of skippedDefinitions) {
-            definitions.delete(definition);
-        }
-        return {
-            definitions: [...definitions],
-            textSpan: result.textSpan,
-        };
-        function visit(node, definition, sourceFile) {
-            if (ts.isPropertySignature(node) && node.type) {
-                proxy(node.name, node.type, definition, sourceFile);
-            }
-            else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.type && !node.initializer) {
-                proxy(node.name, node.type, definition, sourceFile);
-            }
-            else {
-                ts.forEachChild(node, child => visit(child, definition, sourceFile));
-            }
-        }
-        function proxy(name, type, definition, sourceFile) {
-            const { textSpan, fileName } = definition;
-            const start = name.getStart(sourceFile);
-            const end = name.getEnd();
-            if (start !== textSpan.start || end - start !== textSpan.length) {
-                return;
-            }
-            if (!ts.isIndexedAccessTypeNode(type)) {
-                return;
-            }
-            const pos = type.indexType.getStart(sourceFile);
-            const res = getDefinitionAndBoundSpan(fileName, pos);
-            if (res?.definitions?.length) {
-                for (const definition of res.definitions) {
-                    definitions.add(definition);
-                }
-                skippedDefinitions.push(definition);
-            }
-        }
-    };
-}
-function getQuickInfoAtPosition(ts, languageService, getQuickInfoAtPosition) {
-    return (...args) => {
-        const result = getQuickInfoAtPosition(...args);
-        if (result && result.documentation?.length === 1 && result.documentation[0].text.startsWith('__VLS_emit,')) {
-            const [_, emitVarName, eventName] = result.documentation[0].text.split(',');
-            const program = languageService.getProgram();
-            const typeChecker = program.getTypeChecker();
-            const sourceFile = program.getSourceFile(args[0]);
-            result.documentation = undefined;
-            let symbolNode;
-            sourceFile?.forEachChild(function visit(node) {
-                if (ts.isIdentifier(node) && node.text === emitVarName) {
-                    symbolNode = node;
-                }
-                if (symbolNode) {
-                    return;
-                }
-                ts.forEachChild(node, visit);
-            });
-            if (symbolNode) {
-                const emitSymbol = typeChecker.getSymbolAtLocation(symbolNode);
-                if (emitSymbol) {
-                    const type = typeChecker.getTypeOfSymbolAtLocation(emitSymbol, symbolNode);
-                    const calls = type.getCallSignatures();
-                    for (const call of calls) {
-                        const callEventName = typeChecker.getTypeOfSymbolAtLocation(call.parameters[0], symbolNode).value;
-                        call.getJsDocTags();
-                        if (callEventName === eventName) {
-                            result.documentation = call.getDocumentationComment(typeChecker);
-                            result.tags = call.getJsDocTags();
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    };
-}
-function getEncodedSemanticClassifications(ts, language, languageService, asScriptId, getEncodedSemanticClassifications) {
-    return (filePath, span, format) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const result = getEncodedSemanticClassifications(fileName, span, format);
-        const sourceScript = language.scripts.get(asScriptId(fileName));
-        const root = sourceScript?.generated?.root;
-        if (root instanceof language_core_1.VueVirtualCode) {
-            const { template } = root.sfc;
-            if (template) {
-                for (const componentSpan of getComponentSpans.call({ typescript: ts, languageService }, root, template, {
-                    start: span.start - template.startTagEnd,
-                    length: span.length,
-                })) {
-                    result.spans.push(componentSpan.start + template.startTagEnd, componentSpan.length, 256 // class
-                    );
-                }
-            }
-        }
-        return result;
-    };
-}
-function getComponentSpans(vueCode, template, spanTemplateRange) {
-    const { typescript: ts, languageService } = this;
-    const result = [];
-    const validComponentNames = (0, getComponentNames_1._getComponentNames)(ts, languageService, vueCode);
-    const elements = new Set((0, getElementNames_1._getElementNames)(ts, languageService, vueCode));
-    const components = new Set([
-        ...validComponentNames,
-        ...validComponentNames.map(language_core_1.hyphenateTag),
-    ]);
-    if (template.ast) {
-        for (const node of (0, language_core_1.forEachElementNode)(template.ast)) {
-            if (node.loc.end.offset <= spanTemplateRange.start || node.loc.start.offset >= (spanTemplateRange.start + spanTemplateRange.length)) {
-                continue;
-            }
-            if (components.has(node.tag) && !elements.has(node.tag)) {
-                let start = node.loc.start.offset;
-                if (template.lang === 'html') {
-                    start += '<'.length;
-                }
-                result.push({
-                    start,
-                    length: node.tag.length,
-                });
-                if (template.lang === 'html' && !node.isSelfClosing) {
-                    result.push({
-                        start: node.loc.start.offset + node.loc.source.lastIndexOf(node.tag),
-                        length: node.tag.length,
-                    });
-                }
-            }
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=proxy.js.map

package/lib/requests/getDefineSlots.d.ts

@@ -1,2 +0,0 @@
-import type { RequestContext } from './types';
-export declare function getDefineSlots(this: RequestContext, fileName: string): string[] | undefined;

package/lib/requests/getDefineSlots.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefineSlots = getDefineSlots;
-const language_core_1 = require("@vue/language-core");
-const utils_1 = require("./utils");
-function getDefineSlots(fileName) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    const slots = (0, utils_1.getTypeAliasType)(ts, languageService, vueCode, '__VLS_Slots');
-    return slots?.type.getProperties().map(prop => prop.getName());
-}
-//# sourceMappingURL=getDefineSlots.js.map