@vue/typescript-plugin 3.0.7-alpha.0 → 3.0.7

package/index.js

@@ -11,13 +11,14 @@ const getComponentSlots_1 = require("./lib/requests/getComponentSlots");
 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 getReactiveReferences_1 = require("./lib/requests/getReactiveReferences");
+const isRefAtPosition_1 = require("./lib/requests/isRefAtPosition");
 const windowsPathReg = /\\/g;
 const project2Service = new WeakMap();
 module.exports = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)((ts, info) => {
     const vueOptions = getVueCompilerOptions();
-    vue.writeGlobalTypes(vueOptions, ts.sys.writeFile);
     const languagePlugin = vue.createVueLanguagePlugin(ts, info.languageServiceHost.getCompilationSettings(), vueOptions, id => id);
+    vue.writeGlobalTypes(vueOptions, ts.sys.writeFile);
     addVueCommands();
     return {
         languagePlugins: [languagePlugin],
@@ -47,135 +48,130 @@ module.exports = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)(
     function addVueCommands() {
         const projectService = info.project.projectService;
         projectService.logger.info('Vue: called handler processing ' + info.project.projectKind);
-        const session = info.session;
-        if (!session) {
+        if (!info.session) {
             projectService.logger.info('Vue: there is no session in info.');
             return;
         }
+        const session = info.session;
         if (!session.addProtocolHandler) {
             // 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.handlers.has('_vue:projectInfo')) {
+        // @ts-expect-error
+        const handlers = session.handlers;
+        if (handlers.has('_vue:projectInfo')) {
             return;
         }
         session.addProtocolHandler('_vue:projectInfo', request => {
-            return session.handlers.get('projectInfo')?.(request);
+            return handlers.get('projectInfo')(request);
         });
         session.addProtocolHandler('_vue:documentHighlights-full', request => {
-            return session.handlers.get('documentHighlights-full')?.(request);
+            return handlers.get('documentHighlights-full')(request);
         });
         session.addProtocolHandler('_vue:encodedSemanticClassifications-full', request => {
-            return session.handlers.get('encodedSemanticClassifications-full')?.(request);
+            return handlers.get('encodedSemanticClassifications-full')(request);
         });
         session.addProtocolHandler('_vue:quickinfo', request => {
-            return session.handlers.get('quickinfo')?.(request);
+            return handlers.get('quickinfo')(request);
         });
         session.addProtocolHandler('_vue:collectExtractProps', request => {
             const [fileName, templateCodeRange] = request.arguments;
-            const { language, program, sourceScript, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
-            return {
-                response: (0, collectExtractProps_1.collectExtractProps)(ts, language, program, sourceScript, virtualCode, templateCodeRange),
-            };
+            const { language, languageService, sourceScript, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
+            return createResponse((0, collectExtractProps_1.collectExtractProps)(ts, language, languageService.getProgram(), sourceScript, virtualCode, templateCodeRange, sourceScript.generated ? sourceScript.snapshot.getLength() : 0));
         });
         session.addProtocolHandler('_vue:getImportPathForFile', request => {
             const [fileName, incomingFileName, preferences] = request.arguments;
-            const { languageServiceHost, program } = getLanguageService(fileName);
-            return {
-                response: (0, getImportPathForFile_1.getImportPathForFile)(ts, languageServiceHost, program, fileName, incomingFileName, preferences),
-            };
+            const { languageServiceHost, languageService } = getLanguageService(fileName);
+            return createResponse((0, getImportPathForFile_1.getImportPathForFile)(ts, languageServiceHost, languageService.getProgram(), fileName, incomingFileName, preferences));
         });
-        session.addProtocolHandler('_vue:getPropertiesAtLocation', request => {
+        session.addProtocolHandler('_vue:isRefAtPosition', request => {
             const [fileName, position] = request.arguments;
-            const { language, program, sourceScript, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
-            return {
-                response: (0, getPropertiesAtLocation_1.getPropertiesAtLocation)(ts, language, program, sourceScript, virtualCode, position),
-            };
+            const { language, languageService, sourceScript, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
+            return createResponse((0, isRefAtPosition_1.isRefAtPosition)(ts, language, languageService.getProgram(), sourceScript, virtualCode, position, sourceScript.generated ? sourceScript.snapshot.getLength() : 0));
         });
         session.addProtocolHandler('_vue:getComponentDirectives', request => {
             const [fileName] = request.arguments;
-            const { program } = getLanguageService(fileName);
-            return {
-                response: (0, getComponentDirectives_1.getComponentDirectives)(ts, program, fileName),
-            };
+            const { languageService } = getLanguageService(fileName);
+            return createResponse((0, getComponentDirectives_1.getComponentDirectives)(ts, languageService.getProgram(), fileName));
         });
         session.addProtocolHandler('_vue:getComponentEvents', request => {
             const [fileName, tag] = request.arguments;
-            const { program } = getLanguageService(fileName);
-            return {
-                response: (0, getComponentEvents_1.getComponentEvents)(ts, program, fileName, tag),
-            };
+            const { languageService } = getLanguageService(fileName);
+            return createResponse((0, getComponentEvents_1.getComponentEvents)(ts, languageService.getProgram(), fileName, tag));
         });
         session.addProtocolHandler('_vue:getComponentNames', request => {
             const [fileName] = request.arguments;
-            const { program } = getLanguageService(fileName);
-            return {
-                response: (0, getComponentNames_1.getComponentNames)(ts, program, fileName),
-            };
+            const { languageService } = getLanguageService(fileName);
+            return createResponse((0, getComponentNames_1.getComponentNames)(ts, languageService.getProgram(), fileName));
         });
         session.addProtocolHandler('_vue:getComponentProps', request => {
             const [fileName, tag] = request.arguments;
-            const { program } = getLanguageService(fileName);
-            return {
-                response: (0, getComponentProps_1.getComponentProps)(ts, program, fileName, tag),
-            };
+            const { languageService } = getLanguageService(fileName);
+            return createResponse((0, getComponentProps_1.getComponentProps)(ts, languageService.getProgram(), fileName, tag));
         });
         session.addProtocolHandler('_vue:getComponentSlots', request => {
             const [fileName] = request.arguments;
-            const { program, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
-            return {
-                response: (0, getComponentSlots_1.getComponentSlots)(ts, program, virtualCode),
-            };
+            const { languageService, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
+            return createResponse((0, getComponentSlots_1.getComponentSlots)(ts, languageService.getProgram(), virtualCode));
         });
         session.addProtocolHandler('_vue:getElementAttrs', request => {
             const [fileName, tag] = request.arguments;
-            const { program } = getLanguageService(fileName);
-            return {
-                response: (0, getElementAttrs_1.getElementAttrs)(ts, program, fileName, tag),
-            };
+            const { languageService } = getLanguageService(fileName);
+            return createResponse((0, getElementAttrs_1.getElementAttrs)(ts, languageService.getProgram(), fileName, tag));
         });
         session.addProtocolHandler('_vue:getElementNames', request => {
             const [fileName] = request.arguments;
-            const { program } = getLanguageService(fileName);
-            return {
-                response: (0, getElementNames_1.getElementNames)(ts, program, fileName),
-            };
+            const { languageService } = getLanguageService(fileName);
+            return createResponse((0, getElementNames_1.getElementNames)(ts, languageService.getProgram(), fileName));
+        });
+        session.addProtocolHandler('_vue:getReactiveReferences', request => {
+            const [fileName, position] = request.arguments;
+            const { languageService, language } = getLanguageService(fileName);
+            const sourceScript = language.scripts.get(fileName);
+            return createResponse((0, getReactiveReferences_1.getReactiveReferences)(ts, language, languageService, sourceScript, fileName, position, sourceScript?.generated ? sourceScript.snapshot.getLength() : 0));
         });
         projectService.logger.info('Vue specific commands are successfully added.');
-    }
-    function getLanguageServiceAndVirtualCode(fileName) {
-        const service = getLanguageService(fileName);
-        const sourceScript = service?.language.scripts.get(fileName);
-        if (!sourceScript) {
-            throw new Error('No source script found for file: ' + fileName);
+        function createResponse(res) {
+            return {
+                response: res,
+                responseRequired: true,
+            };
         }
-        const virtualCode = sourceScript.generated?.root;
-        if (!(virtualCode instanceof vue.VueVirtualCode)) {
-            throw new Error('No virtual code found for file: ' + fileName);
+        function getLanguageServiceAndVirtualCode(fileName) {
+            const service = getLanguageService(fileName);
+            const sourceScript = service.language.scripts.get(fileName);
+            if (!sourceScript) {
+                throw new Error('No source script found for file: ' + fileName);
+            }
+            const virtualCode = sourceScript.generated?.root;
+            if (!(virtualCode instanceof vue.VueVirtualCode)) {
+                throw new Error('No virtual code found for file: ' + fileName);
+            }
+            return {
+                ...service,
+                sourceScript,
+                virtualCode,
+            };
         }
-        return {
-            ...service,
-            sourceScript,
-            virtualCode,
-        };
-    }
-    function getLanguageService(fileName) {
-        const { project } = info.session.getFileAndProject({
-            file: fileName,
-            projectFileName: undefined,
-        });
-        const service = project2Service.get(project);
-        if (!service) {
-            throw new Error('No vue service for project: ' + project.getProjectName());
+        function getLanguageService(fileName) {
+            // @ts-expect-error
+            const { project } = session.getFileAndProject({
+                file: fileName,
+                projectFileName: undefined,
+            });
+            const service = project2Service.get(project);
+            if (!service) {
+                throw new Error('No vue service for project: ' + project.getProjectName());
+            }
+            const [language, languageServiceHost, languageService] = service;
+            return {
+                typescript: ts,
+                languageService,
+                languageServiceHost,
+                language,
+            };
         }
-        const [language, languageServiceHost, languageService] = service;
-        return {
-            typescript: ts,
-            program: languageService.getProgram(),
-            languageServiceHost,
-            language,
-        };
     }
 });
 //# sourceMappingURL=index.js.map

package/lib/common.js

@@ -20,14 +20,12 @@ function createVueLanguageServiceProxy(ts, language, languageService, vueOptions
     };
     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;
-                }
+            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);
         },

package/lib/proxy.d.ts

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

package/lib/proxy.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVueLanguageServiceProxy = createVueLanguageServiceProxy;
+const language_core_1 = require("@vue/language-core");
+const shared_1 = require("@vue/shared");
+const windowsPathReg = /\\/g;
+function createVueLanguageServiceProxy(ts, language, languageService, vueOptions) {
+    const proxyCache = new Map();
+    const getProxyMethod = (target, p) => {
+        switch (p) {
+            case 'getCompletionsAtPosition':
+                return getCompletionsAtPosition(ts, language, vueOptions, target[p]);
+            case 'getCompletionEntryDetails':
+                return getCompletionEntryDetails(language, target[p]);
+            case 'getCodeFixesAtPosition':
+                return getCodeFixesAtPosition(target[p]);
+            case 'getDefinitionAndBoundSpan':
+                return getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, target[p]);
+        }
+    };
+    return new Proxy(languageService, {
+        get(target, p, receiver) {
+            if (!proxyCache.has(p)) {
+                proxyCache.set(p, getProxyMethod(target, p));
+            }
+            return proxyCache.get(p) ?? Reflect.get(target, p, receiver);
+        },
+    });
+}
+function getCompletionsAtPosition(ts, language, 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_'));
+            // filter global variables in template and styles
+            const sourceScript = language.scripts.get(fileName);
+            const root = sourceScript?.generated?.root;
+            if (root instanceof language_core_1.VueVirtualCode) {
+                const blocks = [
+                    root.sfc.template,
+                    ...root.sfc.styles,
+                ];
+                const ranges = blocks.filter(Boolean).map(block => [
+                    block.startTagEnd,
+                    block.endTagStart,
+                ]);
+                if (ranges.some(([start, end]) => position >= start && position <= end)) {
+                    const globalKinds = new Set(['var', 'function', 'module']);
+                    const globalsOrKeywords = ts.Completions.SortText.GlobalsOrKeywords;
+                    const sortTexts = new Set([
+                        globalsOrKeywords,
+                        'z' + globalsOrKeywords,
+                        globalsOrKeywords + '1',
+                    ]);
+                    result.entries = result.entries.filter(entry => !(entry.kind === 'const' && entry.name in vueOptions.macros) && (!globalKinds.has(entry.kind)
+                        || !sortTexts.has(entry.sortText)
+                        || (0, shared_1.isGloballyAllowed)(entry.name)));
+                }
+            }
+            // 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, getCompletionEntryDetails) {
+    return (...args) => {
+        const details = getCompletionEntryDetails(...args);
+        // modify import statement
+        // @ts-expect-error
+        if (args[6]?.__isComponentAutoImport) {
+            // @ts-expect-error
+            const { 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(fileName);
+            if (sourceScript?.generated?.root instanceof language_core_1.VueVirtualCode) {
+                const { sfc } = sourceScript.generated.root;
+                if (!sfc.script && !sfc.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, getDefinitionAndBoundSpan) {
+    return (fileName, position) => {
+        const result = getDefinitionAndBoundSpan(fileName, position);
+        if (!result?.definitions?.length) {
+            return result;
+        }
+        const program = languageService.getProgram();
+        const sourceScript = language.scripts.get(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);
+            }
+        }
+    };
+}
+//# sourceMappingURL=proxy.js.map

package/lib/requests/collectExtractProps.d.ts

@@ -5,5 +5,5 @@ interface ExtractPropsInfo {
     type: string;
     model: boolean;
 }
-export declare function collectExtractProps(ts: typeof import('typescript'), language: Language, program: ts.Program, sourceScript: SourceScript, virtualCode: VueVirtualCode, templateCodeRange: [number, number]): ExtractPropsInfo[];
+export declare function collectExtractProps(ts: typeof import('typescript'), language: Language, program: ts.Program, sourceScript: SourceScript, virtualCode: VueVirtualCode, templateCodeRange: [number, number], leadingOffset?: number): ExtractPropsInfo[];
 export {};

package/lib/requests/collectExtractProps.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectExtractProps = collectExtractProps;
 const language_core_1 = require("@vue/language-core");
-function collectExtractProps(ts, language, program, sourceScript, virtualCode, templateCodeRange) {
+function collectExtractProps(ts, language, program, sourceScript, virtualCode, templateCodeRange, leadingOffset = 0) {
     const result = new Map();
     const sourceFile = program.getSourceFile(virtualCode.fileName);
     const checker = program.getTypeChecker();
@@ -17,7 +17,7 @@ function collectExtractProps(ts, language, program, sourceScript, virtualCode, t
             const { name } = node;
             for (const map of maps) {
                 let mapped = false;
-                for (const source of map.toSourceLocation(name.getEnd() - sourceScript.snapshot.getLength())) {
+                for (const source of map.toSourceLocation(name.getEnd() - leadingOffset)) {
                     if (source[0] >= sfc.template.startTagEnd + templateCodeRange[0]
                         && source[0] <= sfc.template.startTagEnd + templateCodeRange[1]
                         && (0, language_core_1.isSemanticTokensEnabled)(source[1].data)) {

package/lib/requests/getComponentEvents.js

@@ -25,8 +25,8 @@ function getComponentEvents(ts, program, fileName, tag) {
         if (emitSymbol) {
             const emitType = checker.getTypeOfSymbolAtLocation(emitSymbol, components.node);
             for (const call of emitType.getCallSignatures()) {
-                const eventNameParamSymbol = call.parameters[0];
-                if (eventNameParamSymbol) {
+                if (call.parameters.length) {
+                    const eventNameParamSymbol = call.parameters[0];
                     const eventNameParamType = checker.getTypeOfSymbolAtLocation(eventNameParamSymbol, components.node);
                     if (eventNameParamType.isStringLiteral()) {
                         result.add(eventNameParamType.value);

package/lib/requests/getComponentHighlights.d.ts

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

package/lib/requests/getComponentHighlights.js

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

package/lib/requests/getComponentNames.js

@@ -5,7 +5,7 @@ const utils_1 = require("./utils");
 function getComponentNames(ts, program, fileName) {
     const names = (0, utils_1.getVariableType)(ts, program, fileName, '__VLS_components')
         ?.type
-        ?.getProperties()
+        .getProperties()
         .map(c => c.name)
         .filter(entry => !entry.includes('$') && !entry.startsWith('_'))
         ?? [];

package/lib/requests/getComponentProps.js

@@ -14,8 +14,8 @@ function getComponentProps(ts, program, fileName, tag) {
     const result = new Map();
     const checker = program.getTypeChecker();
     for (const sig of componentType.getCallSignatures()) {
-        const propParam = sig.parameters[0];
-        if (propParam) {
+        if (sig.parameters.length) {
+            const propParam = sig.parameters[0];
             const propsType = checker.getTypeOfSymbolAtLocation(propParam, components.node);
             const props = propsType.getProperties();
             for (const prop of props) {

package/lib/requests/getCurrentComponentSlots.d.ts

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

package/lib/requests/getCurrentComponentSlots.js

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

package/lib/requests/getDefineSlotNames.d.ts

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

package/lib/requests/getDefineSlotNames.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=getDefineSlotNames.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/getElementNames.js

@@ -5,7 +5,7 @@ const utils_1 = require("./utils");
 function getElementNames(ts, program, fileName) {
     return (0, utils_1.getVariableType)(ts, program, fileName, '__VLS_elements')
         ?.type
-        ?.getProperties()
+        .getProperties()
         .map(c => c.name)
         ?? [];
 }

package/lib/requests/getImportPathForFile.d.ts

@@ -1,4 +1,2 @@
 import type * as ts from 'typescript';
-export declare function getImportPathForFile(ts: typeof import('typescript'), languageServiceHost: ts.LanguageServiceHost, program: ts.Program, fileName: string, incomingFileName: string, preferences: ts.UserPreferences): {
-    path?: string;
-};
+export declare function getImportPathForFile(ts: typeof import('typescript'), languageServiceHost: ts.LanguageServiceHost, program: ts.Program, fileName: string, incomingFileName: string, preferences: ts.UserPreferences): string | undefined;

package/lib/requests/getImportPathForFile.js

@@ -4,14 +4,12 @@ exports.getImportPathForFile = getImportPathForFile;
 function getImportPathForFile(ts, languageServiceHost, program, fileName, incomingFileName, preferences) {
     const incomingFile = program.getSourceFile(incomingFileName);
     const sourceFile = program.getSourceFile(fileName);
-    if (!program || !sourceFile || !incomingFile) {
-        return {};
+    if (!sourceFile || !incomingFile) {
+        return;
     }
     const getModuleSpecifiersWithCacheInfo = ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo;
     const resolutionHost = ts.createModuleSpecifierResolutionHost(program, languageServiceHost);
     const { moduleSpecifiers } = getModuleSpecifiersWithCacheInfo(incomingFile.symbol, program.getTypeChecker(), languageServiceHost.getCompilationSettings(), sourceFile, resolutionHost, preferences);
-    return {
-        path: moduleSpecifiers[0],
-    };
+    return moduleSpecifiers[0];
 }
 //# sourceMappingURL=getImportPathForFile.js.map

package/lib/requests/getMissingPropsDiagnostics.d.ts

@@ -0,0 +1,10 @@
+import type { RequestContext } from './types';
+export interface ComponentPropInfo {
+    name: string;
+    required?: boolean;
+    deprecated?: boolean;
+    isAttribute?: boolean;
+    commentMarkdown?: string;
+    values?: string[];
+}
+export declare function getMissingPropsDiagnostics(this: RequestContext, fileName: string): undefined;