@vue/language-service 3.1.5 → 3.1.6

package/index.js

@@ -34,6 +34,7 @@ const vue_directive_comments_1 = require("./lib/plugins/vue-directive-comments")
 const vue_document_drop_1 = require("./lib/plugins/vue-document-drop");
 const vue_document_highlights_1 = require("./lib/plugins/vue-document-highlights");
 const vue_extract_file_1 = require("./lib/plugins/vue-extract-file");
+const vue_format_per_block_1 = require("./lib/plugins/vue-format-per-block");
 const vue_global_types_error_1 = require("./lib/plugins/vue-global-types-error");
 const vue_inlayhints_1 = require("./lib/plugins/vue-inlayhints");
 const vue_missing_props_hints_1 = require("./lib/plugins/vue-missing-props-hints");
@@ -52,13 +53,13 @@ function createVueLanguageServicePlugins(ts, client = new Proxy({}, {
     return [
         (0, volar_service_json_1.create)(),
         (0, volar_service_pug_beautify_1.create)(),
+        (0, vue_format_per_block_1.create)(),
         (0, vue_autoinsert_space_1.create)(),
         (0, vue_compiler_dom_errors_1.create)(),
         (0, vue_directive_comments_1.create)(),
         (0, vue_global_types_error_1.create)(),
         (0, vue_scoped_class_links_1.create)(),
         (0, vue_sfc_1.create)(),
-        (0, vue_suggest_define_assignment_1.create)(),
         (0, vue_template_ref_links_1.create)(),
         (0, volar_service_emmet_1.create)({
             mappedLanguages: {
@@ -67,6 +68,7 @@ function createVueLanguageServicePlugins(ts, client = new Proxy({}, {
             },
         }),
         // TS related plugins
+        (0, vue_suggest_define_assignment_1.create)(ts),
         (0, docCommentTemplate_1.create)(ts),
         (0, syntactic_1.create)(ts),
         (0, vue_inlayhints_1.create)(ts),
@@ -79,8 +81,8 @@ function createVueLanguageServicePlugins(ts, client = new Proxy({}, {
         (0, vue_document_highlights_1.create)(client),
         (0, vue_extract_file_1.create)(ts, client),
         (0, vue_missing_props_hints_1.create)(client),
-        (0, vue_template_1.create)('html', client),
-        (0, vue_template_1.create)('jade', client),
+        (0, vue_template_1.create)(ts, 'html', client),
+        (0, vue_template_1.create)(ts, 'jade', client),
         (0, vue_twoslash_queries_1.create)(client),
     ];
 }

package/lib/htmlFormatter.d.ts

@@ -0,0 +1,2 @@
+import { type HTMLFormatConfiguration, Range, type TextDocument, type TextEdit } from 'vscode-html-languageservice';
+export declare function format(document: TextDocument, range: Range | undefined, options: HTMLFormatConfiguration, voidElements?: string[]): TextEdit[];

package/lib/htmlFormatter.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+// @ts-expect-error
+const beautify = require("vscode-html-languageservice/lib/umd/beautify/beautify-html.js");
+// @ts-expect-error
+const strings = require("vscode-html-languageservice/lib/umd/utils/strings.js");
+/*
+ * original file: https://github.com/microsoft/vscode-html-languageservice/blob/main/src/services/htmlFormatter.ts
+ * commit: a134f3050c22fe80954241467cd429811792a81d (2024-03-22)
+ * purpose: override to add void_elements option
+ */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+function format(document, range, options, voidElements) {
+    let value = document.getText();
+    let includesEnd = true;
+    let initialIndentLevel = 0;
+    const tabSize = options.tabSize || 4;
+    if (range) {
+        let startOffset = document.offsetAt(range.start);
+        // include all leading whitespace iff at the beginning of the line
+        let extendedStart = startOffset;
+        while (extendedStart > 0 && isWhitespace(value, extendedStart - 1)) {
+            extendedStart--;
+        }
+        if (extendedStart === 0 || isEOL(value, extendedStart - 1)) {
+            startOffset = extendedStart;
+        }
+        else {
+            // else keep at least one whitespace
+            if (extendedStart < startOffset) {
+                startOffset = extendedStart + 1;
+            }
+        }
+        // include all following whitespace until the end of the line
+        let endOffset = document.offsetAt(range.end);
+        let extendedEnd = endOffset;
+        while (extendedEnd < value.length && isWhitespace(value, extendedEnd)) {
+            extendedEnd++;
+        }
+        if (extendedEnd === value.length || isEOL(value, extendedEnd)) {
+            endOffset = extendedEnd;
+        }
+        range = vscode_html_languageservice_1.Range.create(document.positionAt(startOffset), document.positionAt(endOffset));
+        // Do not modify if substring starts in inside an element
+        // Ending inside an element is fine as it doesn't cause formatting errors
+        const firstHalf = value.substring(0, startOffset);
+        if (new RegExp(/.*[<][^>]*$/).test(firstHalf)) {
+            // return without modification
+            value = value.substring(startOffset, endOffset);
+            return [{
+                    range: range,
+                    newText: value,
+                }];
+        }
+        includesEnd = endOffset === value.length;
+        value = value.substring(startOffset, endOffset);
+        if (startOffset !== 0) {
+            const startOfLineOffset = document.offsetAt(vscode_html_languageservice_1.Position.create(range.start.line, 0));
+            initialIndentLevel = computeIndentLevel(document.getText(), startOfLineOffset, options);
+        }
+    }
+    else {
+        range = vscode_html_languageservice_1.Range.create(vscode_html_languageservice_1.Position.create(0, 0), document.positionAt(value.length));
+    }
+    const htmlOptions = {
+        indent_size: tabSize,
+        indent_char: options.insertSpaces ? ' ' : '\t',
+        indent_empty_lines: getFormatOption(options, 'indentEmptyLines', false),
+        wrap_line_length: getFormatOption(options, 'wrapLineLength', 120),
+        unformatted: getTagsFormatOption(options, 'unformatted', void 0),
+        content_unformatted: getTagsFormatOption(options, 'contentUnformatted', void 0),
+        indent_inner_html: getFormatOption(options, 'indentInnerHtml', false),
+        preserve_newlines: getFormatOption(options, 'preserveNewLines', true),
+        max_preserve_newlines: getFormatOption(options, 'maxPreserveNewLines', 32786),
+        indent_handlebars: getFormatOption(options, 'indentHandlebars', false),
+        end_with_newline: includesEnd && getFormatOption(options, 'endWithNewline', false),
+        extra_liners: getTagsFormatOption(options, 'extraLiners', void 0),
+        wrap_attributes: getFormatOption(options, 'wrapAttributes', 'auto'),
+        wrap_attributes_indent_size: getFormatOption(options, 'wrapAttributesIndentSize', void 0),
+        eol: '\n',
+        indent_scripts: getFormatOption(options, 'indentScripts', 'normal'),
+        templating: getTemplatingFormatOption(options, 'all'),
+        unformatted_content_delimiter: getFormatOption(options, 'unformattedContentDelimiter', ''),
+        ...voidElements !== undefined && { void_elements: voidElements },
+    };
+    let result = beautify.html_beautify(trimLeft(value), htmlOptions);
+    if (initialIndentLevel > 0) {
+        const indent = options.insertSpaces
+            ? strings.repeat(' ', tabSize * initialIndentLevel)
+            : strings.repeat('\t', initialIndentLevel);
+        result = result.split('\n').join('\n' + indent);
+        if (range.start.character === 0) {
+            result = indent + result; // keep the indent
+        }
+    }
+    return [{
+            range: range,
+            newText: result,
+        }];
+}
+function trimLeft(str) {
+    return str.replace(/^\s+/, '');
+}
+function getFormatOption(options, key, dflt) {
+    if (options && options.hasOwnProperty(key)) {
+        const value = options[key];
+        if (value !== null) {
+            return value;
+        }
+    }
+    return dflt;
+}
+function getTagsFormatOption(options, key, dflt) {
+    const list = getFormatOption(options, key, null);
+    if (typeof list === 'string') {
+        if (list.length > 0) {
+            return list.split(',').map(t => t.trim().toLowerCase());
+        }
+        return [];
+    }
+    return dflt;
+}
+function getTemplatingFormatOption(options, dflt) {
+    const value = getFormatOption(options, 'templating', dflt);
+    if (value === true) {
+        return ['auto'];
+    }
+    if (value === false || value === dflt || Array.isArray(value) === false) {
+        return ['none'];
+    }
+    return value;
+}
+function computeIndentLevel(content, offset, options) {
+    let i = offset;
+    let nChars = 0;
+    const tabSize = options.tabSize || 4;
+    while (i < content.length) {
+        const ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+function isEOL(text, offset) {
+    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+}
+function isWhitespace(text, offset) {
+    return ' \t'.indexOf(text.charAt(offset)) !== -1;
+}
+//# sourceMappingURL=htmlFormatter.js.map

package/lib/nameCasing.d.ts

@@ -1,14 +1,12 @@
 import type { LanguageServiceContext } from '@volar/language-service';
 import type { URI } from 'vscode-uri';
-export declare enum TagNameCasing {
+export declare const enum TagNameCasing {
     Kebab = 0,
     Pascal = 1
 }
-export declare enum AttrNameCasing {
+export declare const enum AttrNameCasing {
     Kebab = 0,
     Camel = 1
 }
-export declare function checkCasing(context: LanguageServiceContext, uri: URI): Promise<{
-    tag: TagNameCasing | undefined;
-    attr: AttrNameCasing | undefined;
-}>;
+export declare function getTagNameCasing(context: LanguageServiceContext, uri: URI): Promise<TagNameCasing | undefined>;
+export declare function getAttrNameCasing(context: LanguageServiceContext, uri: URI): Promise<AttrNameCasing | undefined>;

package/lib/nameCasing.js

@@ -1,71 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AttrNameCasing = exports.TagNameCasing = void 0;
-exports.checkCasing = checkCasing;
+exports.getTagNameCasing = getTagNameCasing;
+exports.getAttrNameCasing = getAttrNameCasing;
 const language_core_1 = require("@vue/language-core");
-var TagNameCasing;
-(function (TagNameCasing) {
-    TagNameCasing[TagNameCasing["Kebab"] = 0] = "Kebab";
-    TagNameCasing[TagNameCasing["Pascal"] = 1] = "Pascal";
-})(TagNameCasing || (exports.TagNameCasing = TagNameCasing = {}));
-var AttrNameCasing;
-(function (AttrNameCasing) {
-    AttrNameCasing[AttrNameCasing["Kebab"] = 0] = "Kebab";
-    AttrNameCasing[AttrNameCasing["Camel"] = 1] = "Camel";
-})(AttrNameCasing || (exports.AttrNameCasing = AttrNameCasing = {}));
-async function checkCasing(context, uri) {
-    const detected = detect(context, uri);
-    const [attr, tag] = await Promise.all([
-        context.env.getConfiguration?.('vue.suggest.propNameCasing', uri.toString()),
-        context.env.getConfiguration?.('vue.suggest.componentNameCasing', uri.toString()),
-    ]);
-    const tagNameCasing = detected.tag.length === 1 && (tag === 'preferPascalCase' || tag === 'preferKebabCase')
-        ? detected.tag[0]
-        : (tag === 'preferKebabCase' || tag === 'alwaysKebabCase')
-            ? TagNameCasing.Kebab
-            : TagNameCasing.Pascal;
-    const attrNameCasing = detected.attr.length === 1 && (attr === 'preferCamelCase' || attr === 'preferKebabCase')
-        ? detected.attr[0]
-        : (attr === 'preferCamelCase' || attr === 'alwaysCamelCase')
-            ? AttrNameCasing.Camel
-            : AttrNameCasing.Kebab;
-    return {
-        tag: tagNameCasing,
-        attr: attrNameCasing,
-    };
-}
-const cache = new WeakMap();
-function detect(context, uri) {
+const collectCache = new WeakMap();
+async function getTagNameCasing(context, uri) {
+    const config = await context.env.getConfiguration?.('vue.suggest.componentNameCasing', uri.toString());
+    if (config === 'alwaysKebabCase') {
+        return 0 /* TagNameCasing.Kebab */;
+    }
+    if (config === 'alwaysPascalCase') {
+        return 1 /* TagNameCasing.Pascal */;
+    }
     const root = context.language.scripts.get(uri)?.generated?.root;
-    if (!(root instanceof language_core_1.VueVirtualCode)) {
-        return { tag: [], attr: [] };
+    if (root instanceof language_core_1.VueVirtualCode) {
+        const detectedCasings = detectTagCasing(root);
+        if (detectedCasings.length === 1) {
+            return detectedCasings[0];
+        }
+    }
+    if (config === 'preferKebabCase') {
+        return 0 /* TagNameCasing.Kebab */;
     }
-    return {
-        tag: detectTagCasing(root),
-        attr: detectAttrCasing(root),
-    };
+    return 1 /* TagNameCasing.Pascal */;
 }
-function detectAttrCasing(code) {
-    let tags;
-    if (cache.has(code)) {
-        tags = cache.get(code);
+async function getAttrNameCasing(context, uri) {
+    const config = await context.env.getConfiguration?.('vue.suggest.propNameCasing', uri.toString());
+    if (config === 'alwaysKebabCase') {
+        return 0 /* AttrNameCasing.Kebab */;
+    }
+    if (config === 'alwaysCamelCase') {
+        return 1 /* AttrNameCasing.Camel */;
     }
-    else {
-        cache.set(code, tags = collectTags(code));
+    const root = context.language.scripts.get(uri)?.generated?.root;
+    if (root instanceof language_core_1.VueVirtualCode) {
+        const detectedCasings = detectAttrCasing(root);
+        if (detectedCasings.length === 1) {
+            return detectedCasings[0];
+        }
     }
+    if (config === 'preferKebabCase') {
+        return 0 /* AttrNameCasing.Kebab */;
+    }
+    return 1 /* AttrNameCasing.Camel */;
+}
+function detectAttrCasing(code) {
+    const tags = collectTagsWithCache(code);
     const result = new Set();
-    for (const [, attrs] of tags ?? []) {
+    for (const [, [_, attrs]] of tags) {
         for (const attr of attrs) {
-            // attrName
             if (attr !== (0, language_core_1.hyphenateTag)(attr)) {
-                result.add(AttrNameCasing.Camel);
+                result.add(1 /* AttrNameCasing.Camel */);
                 break;
             }
         }
         for (const attr of attrs) {
-            // attr-name
             if (attr.includes('-')) {
-                result.add(AttrNameCasing.Kebab);
+                result.add(0 /* AttrNameCasing.Kebab */);
                 break;
             }
         }
@@ -73,39 +64,37 @@ function detectAttrCasing(code) {
     return [...result];
 }
 function detectTagCasing(code) {
-    let tags;
-    if (cache.has(code)) {
-        tags = cache.get(code);
-    }
-    else {
-        cache.set(code, tags = collectTags(code));
-    }
+    const tags = collectTagsWithCache(code);
     const result = new Set();
-    for (const [tag] of tags ?? []) {
+    for (const [tag, [tagType]] of tags) {
+        if (tagType === 0
+            || tagType === 3) {
+            continue;
+        }
         if (tag !== (0, language_core_1.hyphenateTag)(tag)) {
-            // TagName
-            result.add(TagNameCasing.Pascal);
+            result.add(1 /* TagNameCasing.Pascal */);
         }
         else {
-            // tag-name
-            result.add(TagNameCasing.Kebab);
+            result.add(0 /* TagNameCasing.Kebab */);
         }
     }
     return [...result];
 }
-function collectTags(root) {
-    if (!(root instanceof language_core_1.VueVirtualCode)) {
-        return undefined;
-    }
-    const ast = root.sfc.template?.ast;
-    if (!ast) {
-        return undefined;
+function collectTagsWithCache(code) {
+    let cache = collectCache.get(code);
+    if (!cache) {
+        const ast = code.sfc.template?.ast;
+        cache = ast ? collectTags(ast) : new Map();
+        collectCache.set(code, cache);
     }
+    return cache;
+}
+function collectTags(ast) {
     const tags = new Map();
     for (const node of (0, language_core_1.forEachElementNode)(ast)) {
         let tag = tags.get(node.tag);
         if (!tag) {
-            tags.set(node.tag, tag = []);
+            tags.set(node.tag, tag = [node.tagType, []]);
         }
         for (const prop of node.props) {
             let name;
@@ -118,7 +107,7 @@ function collectTags(root) {
                 name = prop.name;
             }
             if (name !== undefined) {
-                tag.push(name);
+                tag[1].push(name);
             }
         }
     }

package/lib/plugins/css.js

@@ -3,12 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
 const language_core_1 = require("@vue/language-core");
 const volar_service_css_1 = require("volar-service-css");
+const vscode_uri_1 = require("vscode-uri");
 const utils_1 = require("../utils");
 function create({ resolveModuleName }) {
+    let modulePathCache;
     const baseService = (0, volar_service_css_1.create)({
         getDocumentContext(context) {
             return {
-                resolveReference: (0, utils_1.createReferenceResolver)(context, volar_service_css_1.resolveReference, resolveModuleName),
+                resolveReference(ref, base) {
+                    let baseUri = vscode_uri_1.URI.parse(base);
+                    const decoded = context.decodeEmbeddedDocumentUri(baseUri);
+                    if (decoded) {
+                        baseUri = decoded[0];
+                    }
+                    if (modulePathCache
+                        && baseUri.scheme === 'file'
+                        && !ref.startsWith('./')
+                        && !ref.startsWith('../')) {
+                        const map = modulePathCache;
+                        if (!map.has(ref)) {
+                            const fileName = baseUri.fsPath.replace(/\\/g, '/');
+                            const promise = resolveModuleName(fileName, ref);
+                            map.set(ref, promise);
+                            if (promise instanceof Promise) {
+                                promise.then(res => map.set(ref, res));
+                            }
+                        }
+                        const cached = modulePathCache.get(ref);
+                        if (cached instanceof Promise) {
+                            throw cached;
+                        }
+                        if (cached) {
+                            return cached;
+                        }
+                    }
+                    return (0, volar_service_css_1.resolveReference)(ref, baseUri, context.env.workspaceFolders);
+                },
             };
         },
         scssDocumentSelector: ['scss', 'postcss'],
@@ -49,6 +79,24 @@ function create({ resolveModuleName }) {
                         return cssLs.prepareRename(document, position, stylesheet);
                     });
                 },
+                async provideDocumentLinks(document, token) {
+                    modulePathCache = new Map();
+                    while (true) {
+                        try {
+                            const result = await baseServiceInstance.provideDocumentLinks?.(document, token);
+                            modulePathCache = undefined;
+                            return result;
+                        }
+                        catch (e) {
+                            if (e instanceof Promise) {
+                                await e;
+                            }
+                            else {
+                                throw e;
+                            }
+                        }
+                    }
+                },
             };
             function isWithinNavigationVirtualCode(document, position) {
                 const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);

package/lib/plugins/vue-autoinsert-dotvalue.js

@@ -44,7 +44,7 @@ function create(ts, { isRefAtPosition }) {
                         if (sourceOffset < startTagEnd || sourceOffset > endTagStart) {
                             continue;
                         }
-                        if (isBlacklistNode(ts, ast, sourceOffset - startTagEnd, false)) {
+                        if (shouldSkip(ts, ast, sourceOffset - startTagEnd, false)) {
                             return;
                         }
                     }
@@ -68,7 +68,7 @@ function isCharacterTyping(document, change) {
     }
     return charReg.test(lastCharacter) && !charReg.test(nextCharacter);
 }
-function isBlacklistNode(ts, node, pos, allowAccessDotValue) {
+function shouldSkip(ts, node, pos, allowAccessDotValue) {
     if (ts.isVariableDeclaration(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
         return true;
     }
@@ -100,45 +100,45 @@ function isBlacklistNode(ts, node, pos, allowAccessDotValue) {
     else if (ts.isCallExpression(node)
         && ts.isIdentifier(node.expression)
         && isWatchOrUseFunction(node.expression.text)
-        && isTopLevelArgOrArrayTopLevelItemItem(node)) {
+        && isTopLevelArgOrArrayTopLevelItemItem(ts, node, pos)) {
         return true;
     }
     else {
-        let _isBlacklistNode = false;
+        let _shouldSkip = false;
         node.forEachChild(node => {
-            if (_isBlacklistNode) {
+            if (_shouldSkip) {
                 return;
             }
             if (pos >= node.getFullStart() && pos <= node.getEnd()) {
-                if (isBlacklistNode(ts, node, pos, allowAccessDotValue)) {
-                    _isBlacklistNode = true;
+                if (shouldSkip(ts, node, pos, allowAccessDotValue)) {
+                    _shouldSkip = true;
                 }
             }
         });
-        return _isBlacklistNode;
+        return _shouldSkip;
     }
-    function isWatchOrUseFunction(fnName) {
-        return fnName === 'watch'
-            || fnName === 'unref'
-            || fnName === 'triggerRef'
-            || fnName === 'isRef'
-            || (0, language_core_1.hyphenateAttr)(fnName).startsWith('use-');
-    }
-    function isTopLevelArgOrArrayTopLevelItemItem(node) {
-        for (const arg of node.arguments) {
-            if (pos >= arg.getFullStart() && pos <= arg.getEnd()) {
-                if (ts.isIdentifier(arg)) {
-                    return true;
-                }
-                if (ts.isArrayLiteralExpression(arg)) {
-                    for (const el of arg.elements) {
-                        if (pos >= el.getFullStart() && pos <= el.getEnd()) {
-                            return ts.isIdentifier(el);
-                        }
+}
+function isWatchOrUseFunction(fnName) {
+    return fnName === 'watch'
+        || fnName === 'unref'
+        || fnName === 'triggerRef'
+        || fnName === 'isRef'
+        || (0, language_core_1.hyphenateAttr)(fnName).startsWith('use-');
+}
+function isTopLevelArgOrArrayTopLevelItemItem(ts, node, pos) {
+    for (const arg of node.arguments) {
+        if (pos >= arg.getFullStart() && pos <= arg.getEnd()) {
+            if (ts.isIdentifier(arg)) {
+                return true;
+            }
+            if (ts.isArrayLiteralExpression(arg)) {
+                for (const el of arg.elements) {
+                    if (pos >= el.getFullStart() && pos <= el.getEnd()) {
+                        return ts.isIdentifier(el);
                     }
                 }
-                return false;
             }
+            return false;
         }
     }
 }

package/lib/plugins/vue-document-drop.js

@@ -39,7 +39,7 @@ function create(ts, { getImportPathForFile }) {
                     if (!script) {
                         return;
                     }
-                    const casing = await (0, nameCasing_1.checkCasing)(context, info.script.id);
+                    const tagNameCasing = await (0, nameCasing_1.getTagNameCasing)(context, info.script.id);
                     const baseName = path_browserify_1.posix.basename(importUri);
                     const newName = (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
                     const additionalEdit = {};
@@ -90,7 +90,7 @@ function create(ts, { getImportPathForFile }) {
                         }
                     }
                     return {
-                        insertText: `<${casing.tag === nameCasing_1.TagNameCasing.Kebab ? (0, shared_1.hyphenate)(newName) : newName}$0 />`,
+                        insertText: `<${tagNameCasing === 0 /* TagNameCasing.Kebab */ ? (0, shared_1.hyphenate)(newName) : newName}$0 />`,
                         insertTextFormat: 2,
                         additionalEdit,
                     };

package/lib/plugins/vue-format-per-block.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageServicePlugin } from '@volar/language-service';
+export declare function create(): LanguageServicePlugin;

package/lib/plugins/vue-format-per-block.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const vscode_uri_1 = require("vscode-uri");
+function create() {
+    return {
+        name: 'vue-format-per-block',
+        capabilities: {
+            documentFormattingProvider: true,
+            documentOnTypeFormattingProvider: {
+                triggerCharacters: [],
+            },
+        },
+        create(context) {
+            return {
+                async provideDocumentFormattingEdits(document) {
+                    if (await shouldSkip(document)) {
+                        return [];
+                    }
+                    return undefined;
+                },
+                async provideOnTypeFormattingEdits(document) {
+                    if (await shouldSkip(document)) {
+                        return [];
+                    }
+                    return undefined;
+                },
+            };
+            async function shouldSkip(document) {
+                const decoded = context.decodeEmbeddedDocumentUri(vscode_uri_1.URI.parse(document.uri));
+                if (!decoded) {
+                    return false;
+                }
+                const [, embeddedCodeId] = decoded;
+                if (embeddedCodeId === 'script_raw' || embeddedCodeId === 'scriptsetup_raw') {
+                    return await context.env.getConfiguration?.('vue.format.script.enabled') === false;
+                }
+                if (embeddedCodeId.startsWith('style_')) {
+                    return await context.env.getConfiguration?.('vue.format.style.enabled') === false;
+                }
+                if (embeddedCodeId === 'template'
+                    || embeddedCodeId.startsWith('template_inline_ts_')
+                    || embeddedCodeId === 'root_tags') {
+                    return await context.env.getConfiguration?.('vue.format.template.enabled') === false;
+                }
+                return false;
+            }
+        },
+    };
+}
+//# sourceMappingURL=vue-format-per-block.js.map

package/lib/plugins/vue-missing-props-hints.js

@@ -28,7 +28,7 @@ function create({ getComponentNames, getElementNames, getComponentProps }) {
                         return;
                     }
                     const result = [];
-                    const casing = await (0, nameCasing_1.checkCasing)(context, info.script.id);
+                    const attrNameCasing = await (0, nameCasing_1.getAttrNameCasing)(context, info.script.id);
                     const components = await getComponentNames(info.root.fileName) ?? [];
                     const componentProps = new Map();
                     intrinsicElementNames ??= new Set(await getElementNames(info.root.fileName) ?? []);
@@ -113,7 +113,7 @@ function create({ getComponentNames, getElementNames, getComponentProps }) {
                                                     start: document.positionAt(current.labelOffset),
                                                     end: document.positionAt(current.labelOffset),
                                                 },
-                                                newText: ` :${casing.attr === nameCasing_1.AttrNameCasing.Kebab ? (0, language_core_1.hyphenateAttr)(requiredProp) : requiredProp}=`,
+                                                newText: ` :${attrNameCasing === 0 /* AttrNameCasing.Kebab */ ? (0, language_core_1.hyphenateAttr)(requiredProp) : requiredProp}=`,
                                             }],
                                     });
                                 }

package/lib/plugins/vue-scoped-class-links.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
-const language_core_1 = require("@vue/language-core");
+const styleScopedClasses_1 = require("@vue/language-core/lib/codegen/template/styleScopedClasses");
 const utils_1 = require("../utils");
 function create() {
     return {
@@ -17,17 +17,21 @@ function create() {
                         return;
                     }
                     const { sfc } = info.root;
-                    const codegen = language_core_1.tsCodegen.get(sfc);
-                    const option = info.root.vueCompilerOptions.resolveStyleClassNames;
-                    const scopedClasses = codegen?.getGeneratedTemplate()?.scopedClasses ?? [];
+                    if (!sfc.template) {
+                        return;
+                    }
+                    const { resolveStyleClassNames } = info.root.vueCompilerOptions;
+                    if (!resolveStyleClassNames) {
+                        return;
+                    }
+                    const scopedClasses = styleScopedClasses_1.references.get(sfc.template)?.[1] ?? [];
                     const styleClasses = new Map();
-                    for (let i = 0; i < sfc.styles.length; i++) {
-                        const style = sfc.styles[i];
-                        if (option !== true && !(option === 'scoped' && style.scoped)) {
+                    for (const style of sfc.styles) {
+                        if (!(resolveStyleClassNames === true || style.scoped)) {
                             continue;
                         }
-                        const styleDocumentUri = context.encodeEmbeddedDocumentUri(info.script.id, 'style_' + i);
-                        const styleVirtualCode = info.script.generated.embeddedCodes.get('style_' + i);
+                        const styleDocumentUri = context.encodeEmbeddedDocumentUri(info.script.id, style.name);
+                        const styleVirtualCode = info.script.generated.embeddedCodes.get(style.name);
                         if (!styleVirtualCode) {
                             continue;
                         }
@@ -43,7 +47,7 @@ function create() {
                             styleClasses.get(text).push(target);
                         }
                     }
-                    return scopedClasses.flatMap(({ className, offset }) => {
+                    return scopedClasses.flatMap(([className, offset]) => {
                         const range = {
                             start: document.positionAt(offset),
                             end: document.positionAt(offset + className.length),

package/lib/plugins/vue-suggest-define-assignment.d.ts

@@ -1,2 +1,2 @@
 import type { LanguageServicePlugin } from '@volar/language-service';
-export declare function create(): LanguageServicePlugin;
+export declare function create(ts: typeof import('typescript')): LanguageServicePlugin;

package/lib/plugins/vue-suggest-define-assignment.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
 const language_core_1 = require("@vue/language-core");
+const vscode_uri_1 = require("vscode-uri");
 const utils_1 = require("../utils");
-function create() {
+const documentToSourceFile = new WeakMap();
+function create(ts) {
     return {
         name: 'vue-suggest-define-assignment',
         capabilities: {
@@ -12,7 +14,7 @@ function create() {
         create(context) {
             return {
                 isAdditionalCompletion: true,
-                async provideCompletionItems(document) {
+                async provideCompletionItems(document, position) {
                     const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
                     if (!info?.code.id.startsWith('script_')) {
                         return;
@@ -28,6 +30,10 @@ function create() {
                     if (!scriptSetup || !scriptSetupRanges) {
                         return;
                     }
+                    const sourceFile = getSourceFile(ts, document);
+                    if (shouldSkip(ts, sourceFile, document.offsetAt(position))) {
+                        return;
+                    }
                     const result = [];
                     const mappings = [...context.language.maps.forEach(info.code)];
                     addDefineCompletionItem(scriptSetupRanges.defineProps?.statement, scriptSetupRanges.withDefaults?.exp ?? scriptSetupRanges.defineProps?.exp, 'props');
@@ -70,4 +76,34 @@ function create() {
         },
     };
 }
+function shouldSkip(ts, node, pos) {
+    if (ts.isStringLiteral(node) && pos >= node.getFullStart() && pos <= node.getEnd()) {
+        return true;
+    }
+    else if (ts.isTemplateLiteral(node) && pos >= node.getFullStart() && pos <= node.getEnd()) {
+        return true;
+    }
+    else {
+        let _shouldSkip = false;
+        node.forEachChild(node => {
+            if (_shouldSkip) {
+                return;
+            }
+            if (pos >= node.getFullStart() && pos <= node.getEnd()) {
+                if (shouldSkip(ts, node, pos)) {
+                    _shouldSkip = true;
+                }
+            }
+        });
+        return _shouldSkip;
+    }
+}
+function getSourceFile(ts, document) {
+    let sourceFile = documentToSourceFile.get(document);
+    if (!sourceFile) {
+        sourceFile = ts.createSourceFile(vscode_uri_1.URI.parse(document.uri).path, document.getText(), ts.ScriptTarget.Latest);
+        documentToSourceFile.set(document, sourceFile);
+    }
+    return sourceFile;
+}
 //# sourceMappingURL=vue-suggest-define-assignment.js.map

package/lib/plugins/vue-template.d.ts

@@ -1,2 +1,2 @@
-import type { LanguageServicePlugin } from '@volar/language-service';
-export declare function create(languageId: 'html' | 'jade', { getComponentNames, getComponentProps, getComponentEvents, getComponentDirectives, getComponentSlots, getElementAttrs, resolveModuleName, }: import('@vue/typescript-plugin/lib/requests').Requests): LanguageServicePlugin;
+import { type LanguageServicePlugin } from '@volar/language-service';
+export declare function create(ts: typeof import('typescript'), languageId: 'html' | 'jade', { getComponentNames, getComponentProps, getComponentEvents, getComponentDirectives, getComponentSlots, getElementAttrs, resolveModuleName, getAutoImportSuggestions, resolveAutoImportCompletionEntry, }: import('@vue/typescript-plugin/lib/requests').Requests): LanguageServicePlugin;

package/lib/plugins/vue-template.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
+const language_service_1 = require("@volar/language-service");
+const featureWorkers_1 = require("@volar/language-service/lib/utils/featureWorkers");
 const language_core_1 = require("@vue/language-core");
 const shared_1 = require("@vue/shared");
 const volar_service_html_1 = require("volar-service-html");
 const volar_service_pug_1 = require("volar-service-pug");
+const getFormatCodeSettings_js_1 = require("volar-service-typescript/lib/configs/getFormatCodeSettings.js");
+const getUserPreferences_js_1 = require("volar-service-typescript/lib/configs/getUserPreferences.js");
+const lspConverters_js_1 = require("volar-service-typescript/lib/utils/lspConverters.js");
 const html = require("vscode-html-languageservice");
 const vscode_uri_1 = require("vscode-uri");
 const data_1 = require("../data");
+const htmlFormatter_1 = require("../htmlFormatter");
 const nameCasing_1 = require("../nameCasing");
 const utils_1 = require("../utils");
 const specialTags = new Set([
@@ -23,11 +29,19 @@ const specialProps = new Set([
     'ref',
     'style',
 ]);
+const builtInComponents = new Set([
+    'Transition',
+    'TransitionGroup',
+    'KeepAlive',
+    'Suspense',
+    'Teleport',
+]);
 let builtInData;
 let modelData;
-function create(languageId, { getComponentNames, getComponentProps, getComponentEvents, getComponentDirectives, getComponentSlots, getElementAttrs, resolveModuleName, }) {
+function create(ts, languageId, { getComponentNames, getComponentProps, getComponentEvents, getComponentDirectives, getComponentSlots, getElementAttrs, resolveModuleName, getAutoImportSuggestions, resolveAutoImportCompletionEntry, }) {
     let customData = [];
     let extraCustomData = [];
+    let modulePathCache;
     const onDidChangeCustomDataListeners = new Set();
     const onDidChangeCustomData = (listener) => {
         onDidChangeCustomDataListeners.add(listener);
@@ -53,7 +67,35 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
             useDefaultDataProvider: false,
             getDocumentContext(context) {
                 return {
-                    resolveReference: (0, utils_1.createReferenceResolver)(context, volar_service_html_1.resolveReference, resolveModuleName),
+                    resolveReference(ref, base) {
+                        let baseUri = vscode_uri_1.URI.parse(base);
+                        const decoded = context.decodeEmbeddedDocumentUri(baseUri);
+                        if (decoded) {
+                            baseUri = decoded[0];
+                        }
+                        if (modulePathCache
+                            && baseUri.scheme === 'file'
+                            && !ref.startsWith('./')
+                            && !ref.startsWith('../')) {
+                            const map = modulePathCache;
+                            if (!map.has(ref)) {
+                                const fileName = baseUri.fsPath.replace(/\\/g, '/');
+                                const promise = resolveModuleName(fileName, ref);
+                                map.set(ref, promise);
+                                if (promise instanceof Promise) {
+                                    promise.then(res => map.set(ref, res));
+                                }
+                            }
+                            const cached = modulePathCache.get(ref);
+                            if (cached instanceof Promise) {
+                                throw cached;
+                            }
+                            if (cached) {
+                                return cached;
+                            }
+                        }
+                        return (0, volar_service_html_1.resolveReference)(ref, baseUri, context.env.workspaceFolders);
+                    },
                 };
             },
             getCustomData() {
@@ -101,6 +143,43 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                     }
                     return parseHTMLDocument(document);
                 };
+                htmlService.format = (document, range, options) => {
+                    let voidElements;
+                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
+                    const codegen = info && language_core_1.tsCodegen.get(info.root.sfc);
+                    if (codegen) {
+                        const componentNames = new Set([
+                            ...codegen.getImportComponentNames(),
+                            ...codegen.getSetupExposed(),
+                        ]);
+                        // copied from https://github.com/microsoft/vscode-html-languageservice/blob/10daf45dc16b4f4228987cf7cddf3a7dbbdc7570/src/beautify/beautify-html.js#L2746-L2761
+                        voidElements = [
+                            'area',
+                            'base',
+                            'br',
+                            'col',
+                            'embed',
+                            'hr',
+                            'img',
+                            'input',
+                            'keygen',
+                            'link',
+                            'menuitem',
+                            'meta',
+                            'param',
+                            'source',
+                            'track',
+                            'wbr',
+                            '!doctype',
+                            '?xml',
+                            'basefont',
+                            'isindex',
+                        ].filter(tag => tag
+                            && !componentNames.has(tag)
+                            && !componentNames.has((0, shared_1.capitalize)((0, shared_1.camelize)(tag))));
+                    }
+                    return (0, htmlFormatter_1.format)(document, range, options, voidElements);
+                };
             }
             builtInData ??= (0, data_1.loadTemplateData)(context.env.locale ?? 'en');
             modelData ??= (0, data_1.loadModelModifiersData)(context.env.locale ?? 'en');
@@ -148,13 +227,24 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                 }
             }
             const disposable = context.env.onDidChangeConfiguration?.(() => initializing = undefined);
+            const transformedItems = new WeakSet();
             let initializing;
+            let formattingOptions;
+            let lastCompletionDocument;
             return {
                 ...baseServiceInstance,
                 dispose() {
                     baseServiceInstance.dispose?.();
                     disposable?.dispose();
                 },
+                provideDocumentFormattingEdits(document, range, options, ...rest) {
+                    formattingOptions = options;
+                    return baseServiceInstance.provideDocumentFormattingEdits?.(document, range, options, ...rest);
+                },
+                provideOnTypeFormattingEdits(document, position, key, options, ...rest) {
+                    formattingOptions = options;
+                    return baseServiceInstance.provideOnTypeFormattingEdits?.(document, position, key, options, ...rest);
+                },
                 async provideCompletionItems(document, position, completionContext, token) {
                     if (document.languageId !== languageId) {
                         return;
@@ -163,23 +253,62 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                     if (info?.code.id !== 'template') {
                         return;
                     }
-                    const { result: completionList, target, info: { components, propMap, }, } = await runWithVueData(info.script.id, info.root, () => baseServiceInstance.provideCompletionItems(document, position, completionContext, token));
-                    if (!completionList) {
+                    const { result: htmlCompletion, target, info: { tagNameCasing, components, propMap, }, } = await runWithVueData(info.script.id, info.root, () => baseServiceInstance.provideCompletionItems(document, position, completionContext, token));
+                    if (!htmlCompletion) {
                         return;
                     }
+                    const autoImportPlaceholderIndex = htmlCompletion.items.findIndex(item => item.label === 'AutoImportsPlaceholder');
+                    if (autoImportPlaceholderIndex !== -1) {
+                        const offset = document.offsetAt(position);
+                        const map = context.language.maps.get(info.code, info.script);
+                        let spliced = false;
+                        for (const [sourceOffset] of map.toSourceLocation(offset)) {
+                            const [formatOptions, preferences] = await Promise.all([
+                                (0, getFormatCodeSettings_js_1.getFormatCodeSettings)(context, document, formattingOptions),
+                                (0, getUserPreferences_js_1.getUserPreferences)(context, document),
+                            ]);
+                            const autoImport = await getAutoImportSuggestions(info.root.fileName, sourceOffset, preferences, formatOptions);
+                            if (!autoImport) {
+                                continue;
+                            }
+                            const tsCompletion = (0, lspConverters_js_1.convertCompletionInfo)(ts, autoImport, document, position, entry => entry.data);
+                            const placeholder = htmlCompletion.items[autoImportPlaceholderIndex];
+                            for (const tsItem of tsCompletion.items) {
+                                if (placeholder.textEdit) {
+                                    const newText = tsItem.textEdit?.newText ?? tsItem.label;
+                                    tsItem.textEdit = {
+                                        ...placeholder.textEdit,
+                                        newText: tagNameCasing === 0 /* TagNameCasing.Kebab */
+                                            ? (0, language_core_1.hyphenateTag)(newText)
+                                            : newText,
+                                    };
+                                }
+                                else {
+                                    tsItem.textEdit = undefined;
+                                }
+                            }
+                            htmlCompletion.items.splice(autoImportPlaceholderIndex, 1, ...tsCompletion.items);
+                            spliced = true;
+                            lastCompletionDocument = document;
+                            break;
+                        }
+                        if (!spliced) {
+                            htmlCompletion.items.splice(autoImportPlaceholderIndex, 1);
+                        }
+                    }
                     switch (target) {
                         case 'tag': {
-                            completionList.items.forEach(transformTag);
+                            htmlCompletion.items.forEach(transformTag);
                             break;
                         }
                         case 'attribute': {
-                            addDirectiveModifiers(completionList, document);
-                            completionList.items.forEach(transformAttribute);
+                            addDirectiveModifiers(htmlCompletion, document);
+                            htmlCompletion.items.forEach(transformAttribute);
                             break;
                         }
                     }
                     updateExtraCustomData([]);
-                    return completionList;
+                    return htmlCompletion;
                     function transformTag(item) {
                         const tagName = (0, shared_1.capitalize)((0, shared_1.camelize)(item.label));
                         if (components?.includes(tagName)) {
@@ -277,6 +406,39 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                         }
                     }
                 },
+                async resolveCompletionItem(item) {
+                    if (item.data?.__isAutoImport || item.data?.__isComponentAutoImport) {
+                        const embeddedUri = vscode_uri_1.URI.parse(lastCompletionDocument.uri);
+                        const decoded = context.decodeEmbeddedDocumentUri(embeddedUri);
+                        if (!decoded) {
+                            return item;
+                        }
+                        const sourceScript = context.language.scripts.get(decoded[0]);
+                        if (!sourceScript) {
+                            return item;
+                        }
+                        const [formatOptions, preferences] = await Promise.all([
+                            (0, getFormatCodeSettings_js_1.getFormatCodeSettings)(context, lastCompletionDocument, formattingOptions),
+                            (0, getUserPreferences_js_1.getUserPreferences)(context, lastCompletionDocument),
+                        ]);
+                        const details = await resolveAutoImportCompletionEntry(item.data, preferences, formatOptions);
+                        if (details) {
+                            const virtualCode = sourceScript.generated.embeddedCodes.get(decoded[1]);
+                            const sourceDocument = context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot);
+                            const embeddedDocument = context.documents.get(embeddedUri, virtualCode.languageId, virtualCode.snapshot);
+                            const map = context.language.maps.get(virtualCode, sourceScript);
+                            item = (0, language_service_1.transformCompletionItem)(item, embeddedRange => (0, featureWorkers_1.getSourceRange)([sourceDocument, embeddedDocument, map], embeddedRange), embeddedDocument, context);
+                            (0, lspConverters_js_1.applyCompletionEntryDetails)(ts, item, details, sourceDocument, fileName => vscode_uri_1.URI.file(fileName), () => undefined);
+                            transformedItems.add(item);
+                        }
+                    }
+                    return item;
+                },
+                transformCompletionItem(item) {
+                    if (transformedItems.has(item)) {
+                        return item;
+                    }
+                },
                 provideHover(document, position, token) {
                     if (document.languageId !== languageId) {
                         return;
@@ -293,20 +455,22 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                     return baseServiceInstance.provideHover?.(document, position, token);
                 },
                 async provideDocumentLinks(document, token) {
-                    if (document.languageId !== languageId) {
-                        return;
-                    }
-                    const info = (0, utils_1.resolveEmbeddedCode)(context, document.uri);
-                    if (info?.code.id !== 'template') {
-                        return;
-                    }
-                    const documentLinks = await baseServiceInstance.provideDocumentLinks?.(document, token) ?? [];
-                    for (const link of documentLinks) {
-                        if (link.target && (0, shared_1.isPromise)(link.target)) {
-                            link.target = await link.target;
+                    modulePathCache = new Map();
+                    while (true) {
+                        try {
+                            const result = await baseServiceInstance.provideDocumentLinks?.(document, token);
+                            modulePathCache = undefined;
+                            return result;
+                        }
+                        catch (e) {
+                            if (e instanceof Promise) {
+                                await e;
+                            }
+                            else {
+                                throw e;
+                            }
                         }
                     }
-                    return documentLinks;
                 },
             };
             async function runWithVueData(sourceDocumentUri, root, fn) {
@@ -322,12 +486,13 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
             }
             async function provideHtmlData(sourceDocumentUri, root) {
                 await (initializing ??= initialize());
-                const casing = await (0, nameCasing_1.checkCasing)(context, sourceDocumentUri);
+                const tagNameCasing = await (0, nameCasing_1.getTagNameCasing)(context, sourceDocumentUri);
+                const attrNameCasing = await (0, nameCasing_1.getAttrNameCasing)(context, sourceDocumentUri);
                 for (const tag of builtInData.tags ?? []) {
                     if (specialTags.has(tag.name)) {
                         continue;
                     }
-                    if (casing.tag === nameCasing_1.TagNameCasing.Kebab) {
+                    if (tagNameCasing === 0 /* TagNameCasing.Kebab */) {
                         tag.name = (0, language_core_1.hyphenateTag)(tag.name);
                     }
                     else {
@@ -375,11 +540,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                                 components = [];
                                 tasks.push((async () => {
                                     components = (await getComponentNames(root.fileName) ?? [])
-                                        .filter(name => name !== 'Transition'
-                                        && name !== 'TransitionGroup'
-                                        && name !== 'KeepAlive'
-                                        && name !== 'Suspense'
-                                        && name !== 'Teleport');
+                                        .filter(name => !builtInComponents.has(name));
                                     version++;
                                 })());
                             }
@@ -387,7 +548,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                             const names = new Set();
                             const tags = [];
                             for (const tag of components) {
-                                if (casing.tag === nameCasing_1.TagNameCasing.Kebab) {
+                                if (tagNameCasing === 0 /* TagNameCasing.Kebab */) {
                                     names.add((0, language_core_1.hyphenateTag)(tag));
                                 }
                                 else {
@@ -396,7 +557,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                             }
                             for (const binding of scriptSetupRanges?.bindings ?? []) {
                                 const name = root.sfc.scriptSetup.content.slice(binding.range.start, binding.range.end);
-                                if (casing.tag === nameCasing_1.TagNameCasing.Kebab) {
+                                if (tagNameCasing === 0 /* TagNameCasing.Kebab */) {
                                     names.add((0, language_core_1.hyphenateTag)(name));
                                 }
                                 else {
@@ -450,10 +611,10 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                                 ...attrs.map(attr => ({ name: attr })),
                             ]) {
                                 const isGlobal = prop.isAttribute || !propNameSet.has(prop.name);
-                                const propName = casing.attr === nameCasing_1.AttrNameCasing.Camel ? prop.name : (0, language_core_1.hyphenateAttr)(prop.name);
+                                const propName = attrNameCasing === 1 /* AttrNameCasing.Camel */ ? prop.name : (0, language_core_1.hyphenateAttr)(prop.name);
                                 const isEvent = (0, language_core_1.hyphenateAttr)(propName).startsWith('on-');
                                 if (isEvent) {
-                                    const eventName = casing.attr === nameCasing_1.AttrNameCasing.Camel
+                                    const eventName = attrNameCasing === 1 /* AttrNameCasing.Camel */
                                         ? propName['on'.length].toLowerCase() + propName.slice('onX'.length)
                                         : propName.slice('on-'.length);
                                     for (const name of [
@@ -471,7 +632,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                                 }
                                 else {
                                     const propInfo = propInfos.find(prop => {
-                                        const name = casing.attr === nameCasing_1.AttrNameCasing.Camel ? prop.name : (0, language_core_1.hyphenateAttr)(prop.name);
+                                        const name = attrNameCasing === 1 /* AttrNameCasing.Camel */ ? prop.name : (0, language_core_1.hyphenateAttr)(prop.name);
                                         return name === propName;
                                     });
                                     for (const name of [
@@ -493,7 +654,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                                 }
                             }
                             for (const event of events) {
-                                const eventName = casing.attr === nameCasing_1.AttrNameCasing.Camel ? event : (0, language_core_1.hyphenateAttr)(event);
+                                const eventName = attrNameCasing === 1 /* AttrNameCasing.Camel */ ? event : (0, language_core_1.hyphenateAttr)(event);
                                 for (const name of [
                                     'v-on:' + eventName,
                                     '@' + eventName,
@@ -526,7 +687,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                                 }
                             }
                             for (const model of models) {
-                                const name = casing.attr === nameCasing_1.AttrNameCasing.Camel ? model : (0, language_core_1.hyphenateAttr)(model);
+                                const name = attrNameCasing === 1 /* AttrNameCasing.Camel */ ? model : (0, language_core_1.hyphenateAttr)(model);
                                 attributes.push({ name: 'v-model:' + name });
                                 propMap.set('v-model:' + name, {
                                     name,
@@ -556,6 +717,19 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                             }));
                         },
                     },
+                    {
+                        getId: () => 'vue-auto-imports',
+                        isApplicable: () => true,
+                        provideTags() {
+                            return [{ name: 'AutoImportsPlaceholder', attributes: [] }];
+                        },
+                        provideAttributes() {
+                            return [];
+                        },
+                        provideValues() {
+                            return [];
+                        },
+                    },
                 ]);
                 return {
                     async sync() {
@@ -564,6 +738,7 @@ function create(languageId, { getComponentNames, getComponentProps, getComponent
                             version,
                             target,
                             info: {
+                                tagNameCasing,
                                 components,
                                 propMap,
                             },

package/lib/utils.d.ts

@@ -6,4 +6,3 @@ export declare function resolveEmbeddedCode(context: LanguageServiceContext, uri
     code: import("@volar/language-service").VirtualCode;
     root: VueVirtualCode;
 } | undefined;
-export declare function createReferenceResolver(context: LanguageServiceContext, resolveReference: typeof import('volar-service-html').resolveReference, resolveModuleName: import('@vue/typescript-plugin/lib/requests').Requests['resolveModuleName']): (ref: string, base: string) => Promise<string>;

package/lib/utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveEmbeddedCode = resolveEmbeddedCode;
-exports.createReferenceResolver = createReferenceResolver;
 const vscode_uri_1 = require("vscode-uri");
 function resolveEmbeddedCode(context, uriStr) {
     const uri = vscode_uri_1.URI.parse(uriStr);
@@ -17,18 +16,4 @@ function resolveEmbeddedCode(context, uriStr) {
         root: sourceScript.generated.root,
     };
 }
-function createReferenceResolver(context, resolveReference, resolveModuleName) {
-    return async (ref, base) => {
-        let uri = vscode_uri_1.URI.parse(base);
-        const decoded = context.decodeEmbeddedDocumentUri(uri);
-        if (decoded) {
-            uri = decoded[0];
-        }
-        let moduleName;
-        if (!ref.startsWith('./') && !ref.startsWith('../')) {
-            moduleName = await resolveModuleName(uri.fsPath, ref);
-        }
-        return moduleName ?? resolveReference(ref, uri, context.env.workspaceFolders);
-    };
-}
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-service",
-	"version": "3.1.5",
+	"version": "3.1.6",
 	"license": "MIT",
 	"files": [
 		"data",
@@ -17,8 +17,8 @@
 		"update-html-data": "node ./scripts/update-html-data.js"
 	},
 	"dependencies": {
-		"@volar/language-service": "2.4.23",
-		"@vue/language-core": "3.1.5",
+		"@volar/language-service": "2.4.26",
+		"@vue/language-core": "3.1.6",
 		"@vue/shared": "^3.5.0",
 		"path-browserify": "^1.0.1",
 		"volar-service-css": "0.0.67",
@@ -34,11 +34,11 @@
 	"devDependencies": {
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
-		"@volar/kit": "2.4.23",
-		"@volar/typescript": "2.4.23",
+		"@volar/kit": "2.4.26",
+		"@volar/typescript": "2.4.26",
 		"@vue/compiler-dom": "^3.5.0",
-		"@vue/typescript-plugin": "3.1.5",
+		"@vue/typescript-plugin": "3.1.6",
 		"vscode-css-languageservice": "^6.3.1"
 	},
-	"gitHead": "d124a88fbf169e793c39ae4248da2092098de92d"
+	"gitHead": "341c06897f7f46606dddb8dd6d9e74e9c7844f02"
 }