@vue/typescript-plugin 2.2.6 → 2.2.10

package/lib/commands.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,136 @@
+"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/common.js

@@ -5,6 +5,7 @@ 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 windowsPathReg = /\\/g;
 function proxyLanguageServiceForVue(ts, language, languageService, vueOptions, asScriptId) {
     const proxyCache = new Map();
@@ -13,6 +14,7 @@ function proxyLanguageServiceForVue(ts, language, languageService, vueOptions, a
             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]);
@@ -128,6 +130,77 @@ function getCodeFixesAtPosition(getCodeFixesAtPosition) {
         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 = [];
+        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);
@@ -191,6 +264,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 components = new Set([
         ...validComponentNames,
         ...validComponentNames.map(language_core_1.hyphenateTag),
@@ -200,7 +274,7 @@ function getComponentSpans(vueCode, template, spanTemplateRange) {
             if (node.loc.end.offset <= spanTemplateRange.start || node.loc.start.offset >= (spanTemplateRange.start + spanTemplateRange.length)) {
                 continue;
             }
-            if (components.has(node.tag)) {
+            if (components.has(node.tag) && !elements.has(node.tag)) {
                 let start = node.loc.start.offset;
                 if (template.lang === 'html') {
                     start += '<'.length;

package/lib/proxy.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,305 @@
+"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

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

package/lib/requests/getDefineSlots.js

@@ -0,0 +1,16 @@
+"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

package/lib/requests/getElementAttrs.d.ts

@@ -1,2 +1,5 @@
+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,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getElementAttrs = getElementAttrs;
-const vue = require("@vue/language-core");
+exports._getElementNames = _getElementNames;
+const language_core_1 = require("@vue/language-core");
 function getElementAttrs(fileName, tagName) {
     const { typescript: ts, language, languageService, getFileId } = this;
     const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
+    if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
         return;
     }
     const program = languageService.getProgram();
-    let tsSourceFile;
-    if (tsSourceFile = program.getSourceFile(fileName)) {
+    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 (checker && typeNode) {
+        if (typeNode) {
             const type = checker.getTypeFromTypeNode(typeNode.type);
             const el = type.getProperty(tagName);
             if (el) {
@@ -26,4 +27,19 @@ function getElementAttrs(fileName, tagName) {
     }
     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);
+        }
+    }
+    return [];
+}
 //# sourceMappingURL=getElementAttrs.js.map

package/lib/requests/getElementNames.d.ts

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

package/lib/requests/getElementNames.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementNames = getElementNames;
+exports._getElementNames = _getElementNames;
+const language_core_1 = require("@vue/language-core");
+const utils_1 = require("./utils");
+function getElementNames(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;
+    return _getElementNames(ts, languageService, vueCode);
+}
+function _getElementNames(ts, tsLs, vueCode) {
+    return (0, utils_1.getVariableType)(ts, tsLs, vueCode, '__VLS_elements')
+        ?.type
+        ?.getProperties()
+        .map(c => c.name)
+        ?? [];
+}
+//# sourceMappingURL=getElementNames.js.map

package/lib/requests/index.d.ts

@@ -0,0 +1,17 @@
+type ToRequest<T extends (...args: any) => any> = (...args: Parameters<T>) => Promise<ReturnType<T> | null | undefined>;
+export type Requests = {
+    collectExtractProps: ToRequest<typeof import('./collectExtractProps.js')['collectExtractProps']>;
+    getImportPathForFile: ToRequest<typeof import('./getImportPathForFile.js')['getImportPathForFile']>;
+    getPropertiesAtLocation: ToRequest<typeof import('./getPropertiesAtLocation.js')['getPropertiesAtLocation']>;
+    getComponentNames: ToRequest<typeof import('./getComponentNames.js')['getComponentNames']>;
+    getComponentProps: ToRequest<typeof import('./getComponentProps.js')['getComponentProps']>;
+    getComponentEvents: ToRequest<typeof import('./getComponentEvents.js')['getComponentEvents']>;
+    getComponentDirectives: ToRequest<typeof import('./getComponentDirectives.js')['getComponentDirectives']>;
+    getElementAttrs: ToRequest<typeof import('./getElementAttrs.js')['getElementAttrs']>;
+    getElementNames: ToRequest<typeof import('./getElementNames.js')['getElementNames']>;
+    getQuickInfoAtPosition: ToRequest<(fileName: string, position: {
+        line: number;
+        character: number;
+    }) => string>;
+};
+export {};

package/lib/requests/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/lib/requests/utils.js

@@ -36,11 +36,11 @@ function getSelfComponentName(fileName) {
 }
 function getVariableType(ts, languageService, vueCode, name) {
     const program = languageService.getProgram();
-    let tsSourceFile;
-    if (tsSourceFile = program.getSourceFile(vueCode.fileName)) {
-        const node = searchVariableDeclarationNode(ts, tsSourceFile, name);
+    const tsSourceFile = program.getSourceFile(vueCode.fileName);
+    if (tsSourceFile) {
         const checker = program.getTypeChecker();
-        if (checker && node) {
+        const node = searchVariableDeclarationNode(ts, tsSourceFile, name);
+        if (node) {
             return {
                 node: node,
                 type: checker.getTypeAtLocation(node),
@@ -49,15 +49,15 @@ function getVariableType(ts, languageService, vueCode, name) {
     }
 }
 function searchVariableDeclarationNode(ts, sourceFile, name) {
-    let componentsNode;
+    let result;
     walk(sourceFile);
-    return componentsNode;
+    return result;
     function walk(node) {
-        if (componentsNode) {
+        if (result) {
             return;
         }
         else if (ts.isVariableDeclaration(node) && node.name.getText() === name) {
-            componentsNode = node;
+            result = node;
         }
         else {
             node.forEachChild(walk);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "2.2.6",
+	"version": "2.2.10",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -14,11 +14,11 @@
 	},
 	"dependencies": {
 		"@volar/typescript": "~2.4.11",
-		"@vue/language-core": "2.2.6",
+		"@vue/language-core": "2.2.10",
 		"@vue/shared": "^3.5.0"
 	},
 	"devDependencies": {
 		"@types/node": "^22.10.4"
 	},
-	"gitHead": "f2088e256dc0220db9549d28d9f865a5711dcfbe"
+	"gitHead": "0422c03ffa4958431c9cd3cd19ae51f726c30b07"
 }

package/lib/requests/componentInfos.d.ts

@@ -1,13 +0,0 @@
-import * as vue from '@vue/language-core';
-import type * as ts from 'typescript';
-import type { RequestContext } from './types';
-export declare function getComponentProps(this: RequestContext, fileName: string, tag: string): {
-    name: string;
-    required?: true;
-    commentMarkdown?: string;
-}[] | undefined;
-export declare function getComponentEvents(this: RequestContext, fileName: string, tag: string): string[] | undefined;
-export declare function getTemplateContextProps(this: RequestContext, fileName: string): string[] | undefined;
-export declare function getComponentNames(this: RequestContext, fileName: string): string[] | undefined;
-export declare function _getComponentNames(ts: typeof import('typescript'), tsLs: ts.LanguageService, vueCode: vue.VueVirtualCode): string[];
-export declare function getElementAttrs(this: RequestContext, fileName: string, tagName: string): string[] | undefined;

package/lib/requests/componentInfos.js

@@ -1,249 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getComponentProps = getComponentProps;
-exports.getComponentEvents = getComponentEvents;
-exports.getTemplateContextProps = getTemplateContextProps;
-exports.getComponentNames = getComponentNames;
-exports._getComponentNames = _getComponentNames;
-exports.getElementAttrs = getElementAttrs;
-const vue = require("@vue/language-core");
-const shared_1 = require("@vue/shared");
-function getComponentProps(fileName, tag) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    const program = languageService.getProgram();
-    const checker = program.getTypeChecker();
-    const components = getVariableType(ts, languageService, vueCode, '__VLS_components');
-    if (!components) {
-        return [];
-    }
-    const name = tag.split('.');
-    let componentSymbol = components.type.getProperty(name[0])
-        ?? components.type.getProperty((0, shared_1.camelize)(name[0]))
-        ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
-    if (!componentSymbol) {
-        return [];
-    }
-    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-    for (let i = 1; i < name.length; i++) {
-        componentSymbol = componentType.getProperty(name[i]);
-        if (componentSymbol) {
-            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-        }
-        else {
-            return [];
-        }
-    }
-    const result = new Map();
-    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 commentMarkdown = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags()) || undefined;
-                result.set(name, { name, required, commentMarkdown });
-            }
-        }
-    }
-    for (const sig of componentType.getConstructSignatures()) {
-        const instanceType = sig.getReturnType();
-        const propsSymbol = instanceType.getProperty('$props');
-        if (propsSymbol) {
-            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 commentMarkdown = generateCommentMarkdown(prop.getDocumentationComment(checker), prop.getJsDocTags()) || undefined;
-                result.set(name, { name, required, commentMarkdown });
-            }
-        }
-    }
-    return [...result.values()];
-}
-function getComponentEvents(fileName, tag) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    const program = languageService.getProgram();
-    const checker = program.getTypeChecker();
-    const components = getVariableType(ts, languageService, vueCode, '__VLS_components');
-    if (!components) {
-        return [];
-    }
-    const name = tag.split('.');
-    let componentSymbol = components.type.getProperty(name[0]);
-    if (!componentSymbol) {
-        componentSymbol = components.type.getProperty((0, shared_1.camelize)(name[0]))
-            ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
-    }
-    if (!componentSymbol) {
-        return [];
-    }
-    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-    for (let i = 1; i < name.length; i++) {
-        componentSymbol = componentType.getProperty(name[i]);
-        if (componentSymbol) {
-            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-        }
-        else {
-            return [];
-        }
-    }
-    const result = new Set();
-    // for (const sig of componentType.getCallSignatures()) {
-    // 	const emitParam = sig.parameters[1];
-    // 	if (emitParam) {
-    // 		// TODO
-    // 	}
-    // }
-    for (const sig of componentType.getConstructSignatures()) {
-        const instanceType = sig.getReturnType();
-        const emitSymbol = instanceType.getProperty('$emit');
-        if (emitSymbol) {
-            const emitType = checker.getTypeOfSymbolAtLocation(emitSymbol, components.node);
-            for (const call of emitType.getCallSignatures()) {
-                const eventNameParamSymbol = call.parameters[0];
-                if (eventNameParamSymbol) {
-                    const eventNameParamType = checker.getTypeOfSymbolAtLocation(eventNameParamSymbol, components.node);
-                    if (eventNameParamType.isStringLiteral()) {
-                        result.add(eventNameParamType.value);
-                    }
-                }
-            }
-        }
-    }
-    return [...result];
-}
-function getTemplateContextProps(fileName) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    return getVariableType(ts, languageService, vueCode, '__VLS_ctx')
-        ?.type
-        ?.getProperties()
-        .map(c => c.name);
-}
-function getComponentNames(fileName) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    return getVariableType(ts, languageService, vueCode, '__VLS_components')
-        ?.type
-        ?.getProperties()
-        .map(c => c.name)
-        .filter(entry => !entry.includes('$') && !entry.startsWith('_'))
-        ?? [];
-}
-function _getComponentNames(ts, tsLs, vueCode) {
-    return getVariableType(ts, tsLs, vueCode, '__VLS_components')
-        ?.type
-        ?.getProperties()
-        .map(c => c.name)
-        .filter(entry => !entry.includes('$') && !entry.startsWith('_'))
-        ?? [];
-}
-function getElementAttrs(fileName, tagName) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof vue.VueVirtualCode)) {
-        return;
-    }
-    const program = languageService.getProgram();
-    let tsSourceFile;
-    if (tsSourceFile = program.getSourceFile(fileName)) {
-        const typeNode = tsSourceFile.statements.find((node) => ts.isTypeAliasDeclaration(node) && node.name.getText() === '__VLS_IntrinsicElementsCompletion');
-        const checker = program.getTypeChecker();
-        if (checker && 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);
-            }
-        }
-    }
-    return [];
-}
-function getVariableType(ts, languageService, vueCode, name) {
-    const program = languageService.getProgram();
-    let tsSourceFile;
-    if (tsSourceFile = program.getSourceFile(vueCode.fileName)) {
-        const node = searchVariableDeclarationNode(ts, tsSourceFile, name);
-        const checker = program.getTypeChecker();
-        if (checker && node) {
-            return {
-                node: node,
-                type: checker.getTypeAtLocation(node),
-            };
-        }
-    }
-}
-function searchVariableDeclarationNode(ts, sourceFile, name) {
-    let componentsNode;
-    walk(sourceFile);
-    return componentsNode;
-    function walk(node) {
-        if (componentsNode) {
-            return;
-        }
-        else if (ts.isVariableDeclaration(node) && node.name.getText() === name) {
-            componentsNode = node;
-        }
-        else {
-            node.forEachChild(walk);
-        }
-    }
-}
-function generateCommentMarkdown(parts, jsDocTags) {
-    const parsedComment = _symbolDisplayPartsToMarkdown(parts);
-    const parsedJsDoc = _jsDocTagInfoToMarkdown(jsDocTags);
-    let result = [parsedComment, parsedJsDoc].filter(str => !!str).join('\n\n');
-    return result;
-}
-function _symbolDisplayPartsToMarkdown(parts) {
-    return parts.map(part => {
-        switch (part.kind) {
-            case 'keyword':
-                return `\`${part.text}\``;
-            case 'functionName':
-                return `**${part.text}**`;
-            default:
-                return part.text;
-        }
-    }).join('');
-}
-function _jsDocTagInfoToMarkdown(jsDocTags) {
-    return jsDocTags.map(tag => {
-        const tagName = `*@${tag.name}*`;
-        const tagText = tag.text?.map(t => {
-            if (t.kind === 'parameterName') {
-                return `\`${t.text}\``;
-            }
-            else {
-                return t.text;
-            }
-        }).join('') || '';
-        return `${tagName} ${tagText}`;
-    }).join('\n\n');
-}
-//# sourceMappingURL=componentInfos.js.map