@vue/language-service 2.0.0 → 2.0.2

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from '@volar/language-service';
+export * from '@vue/language-core';
+export * from './lib/ideFeatures/nameCasing';
+export * from './lib/types';
+import type { ServiceEnvironment, ServicePlugin } from '@volar/language-service';
+import type { VueCompilerOptions } from './lib/types';
+export declare function createVueServicePlugins(ts: typeof import('typescript'), getVueOptions: (env: ServiceEnvironment) => VueCompilerOptions): ServicePlugin[];

package/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVueServicePlugins = void 0;
+__exportStar(require("@volar/language-service"), exports);
+__exportStar(require("@vue/language-core"), exports);
+__exportStar(require("./lib/ideFeatures/nameCasing"), exports);
+__exportStar(require("./lib/types"), exports);
+const volar_service_emmet_1 = require("volar-service-emmet");
+const volar_service_json_1 = require("volar-service-json");
+const volar_service_pug_beautify_1 = require("volar-service-pug-beautify");
+const volar_service_typescript_1 = require("volar-service-typescript");
+const volar_service_typescript_twoslash_queries_1 = require("volar-service-typescript-twoslash-queries");
+const css_1 = require("./lib/plugins/css");
+const vue_autoinsert_dotvalue_1 = require("./lib/plugins/vue-autoinsert-dotvalue");
+const vue_autoinsert_parentheses_1 = require("./lib/plugins/vue-autoinsert-parentheses");
+const vue_autoinsert_space_1 = require("./lib/plugins/vue-autoinsert-space");
+const vue_codelens_references_1 = require("./lib/plugins/vue-codelens-references");
+const vue_directive_comments_1 = require("./lib/plugins/vue-directive-comments");
+const vue_document_drop_1 = require("./lib/plugins/vue-document-drop");
+const vue_extract_file_1 = require("./lib/plugins/vue-extract-file");
+const vue_sfc_1 = require("./lib/plugins/vue-sfc");
+const vue_template_1 = require("./lib/plugins/vue-template");
+const vue_toggle_v_bind_codeaction_1 = require("./lib/plugins/vue-toggle-v-bind-codeaction");
+const vue_twoslash_queries_1 = require("./lib/plugins/vue-twoslash-queries");
+const vue_visualize_hidden_callback_param_1 = require("./lib/plugins/vue-visualize-hidden-callback-param");
+function createVueServicePlugins(ts, getVueOptions) {
+    return [
+        (0, volar_service_typescript_1.create)(ts),
+        (0, volar_service_typescript_twoslash_queries_1.create)(),
+        (0, css_1.create)(),
+        (0, volar_service_pug_beautify_1.create)(),
+        (0, volar_service_json_1.create)(),
+        (0, vue_template_1.create)('html', ts, getVueOptions),
+        (0, vue_template_1.create)('pug', ts, getVueOptions),
+        (0, vue_sfc_1.create)(),
+        (0, vue_twoslash_queries_1.create)(ts),
+        (0, vue_codelens_references_1.create)(),
+        (0, vue_document_drop_1.create)(ts),
+        (0, vue_autoinsert_dotvalue_1.create)(ts),
+        (0, vue_autoinsert_parentheses_1.create)(ts),
+        (0, vue_autoinsert_space_1.create)(),
+        (0, vue_visualize_hidden_callback_param_1.create)(),
+        (0, vue_directive_comments_1.create)(),
+        (0, vue_extract_file_1.create)(ts),
+        (0, vue_toggle_v_bind_codeaction_1.create)(ts),
+        (0, volar_service_emmet_1.create)(),
+    ];
+}
+exports.createVueServicePlugins = createVueServicePlugins;
+//# sourceMappingURL=index.js.map

package/lib/ideFeatures/nameCasing.d.ts

@@ -0,0 +1,13 @@
+import type { ServiceContext } from '@volar/language-service';
+import type * as vscode from 'vscode-languageserver-protocol';
+import { AttrNameCasing, TagNameCasing } from '../types';
+export declare function convertTagName(context: ServiceContext, uri: string, casing: TagNameCasing): Promise<vscode.TextEdit[] | undefined>;
+export declare function convertAttrName(context: ServiceContext, uri: string, casing: AttrNameCasing): Promise<vscode.TextEdit[] | undefined>;
+export declare function getNameCasing(context: ServiceContext, uri: string): Promise<{
+    tag: TagNameCasing;
+    attr: AttrNameCasing;
+}>;
+export declare function detect(context: ServiceContext, uri: string): Promise<{
+    tag: TagNameCasing[];
+    attr: AttrNameCasing[];
+}>;

package/lib/ideFeatures/nameCasing.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect = exports.getNameCasing = exports.convertAttrName = exports.convertTagName = void 0;
+const vue = require("@vue/language-core");
+const language_core_1 = require("@vue/language-core");
+const namedPipeClient = require("@vue/typescript-plugin/lib/client");
+const computeds_1 = require("computeds");
+const types_1 = require("../types");
+async function convertTagName(context, uri, casing) {
+    const sourceFile = context.language.files.get(uri);
+    if (!sourceFile)
+        return;
+    const rootCode = sourceFile?.generated?.code;
+    if (!(rootCode instanceof language_core_1.VueGeneratedCode))
+        return;
+    const desc = rootCode.sfc;
+    if (!desc.template)
+        return;
+    const template = desc.template;
+    const document = context.documents.get(sourceFile.id, sourceFile.languageId, sourceFile.snapshot);
+    const edits = [];
+    const components = await namedPipeClient.getComponentNames(rootCode.fileName) ?? [];
+    const tags = getTemplateTagsAndAttrs(rootCode);
+    for (const [tagName, { offsets }] of tags) {
+        const componentName = components.find(component => component === tagName || (0, language_core_1.hyphenateTag)(component) === tagName);
+        if (componentName) {
+            for (const offset of offsets) {
+                const start = document.positionAt(template.startTagEnd + offset);
+                const end = document.positionAt(template.startTagEnd + offset + tagName.length);
+                const range = { start, end };
+                if (casing === types_1.TagNameCasing.Kebab && tagName !== (0, language_core_1.hyphenateTag)(componentName)) {
+                    edits.push({ range, newText: (0, language_core_1.hyphenateTag)(componentName) });
+                }
+                if (casing === types_1.TagNameCasing.Pascal && tagName !== componentName) {
+                    edits.push({ range, newText: componentName });
+                }
+            }
+        }
+    }
+    return edits;
+}
+exports.convertTagName = convertTagName;
+async function convertAttrName(context, uri, casing) {
+    const sourceFile = context.language.files.get(uri);
+    if (!sourceFile)
+        return;
+    const rootCode = sourceFile?.generated?.code;
+    if (!(rootCode instanceof language_core_1.VueGeneratedCode))
+        return;
+    const desc = rootCode.sfc;
+    if (!desc.template)
+        return;
+    const template = desc.template;
+    const document = context.documents.get(uri, sourceFile.languageId, sourceFile.snapshot);
+    const edits = [];
+    const components = await namedPipeClient.getComponentNames(rootCode.fileName) ?? [];
+    const tags = getTemplateTagsAndAttrs(rootCode);
+    for (const [tagName, { attrs }] of tags) {
+        const componentName = components.find(component => component === tagName || (0, language_core_1.hyphenateTag)(component) === tagName);
+        if (componentName) {
+            const props = await namedPipeClient.getComponentProps(rootCode.fileName, componentName) ?? [];
+            for (const [attrName, { offsets }] of attrs) {
+                const propName = props.find(prop => prop === attrName || (0, language_core_1.hyphenateAttr)(prop) === attrName);
+                if (propName) {
+                    for (const offset of offsets) {
+                        const start = document.positionAt(template.startTagEnd + offset);
+                        const end = document.positionAt(template.startTagEnd + offset + attrName.length);
+                        const range = { start, end };
+                        if (casing === types_1.AttrNameCasing.Kebab && attrName !== (0, language_core_1.hyphenateAttr)(propName)) {
+                            edits.push({ range, newText: (0, language_core_1.hyphenateAttr)(propName) });
+                        }
+                        if (casing === types_1.AttrNameCasing.Camel && attrName !== propName) {
+                            edits.push({ range, newText: propName });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return edits;
+}
+exports.convertAttrName = convertAttrName;
+async function getNameCasing(context, uri) {
+    const detected = await detect(context, uri);
+    const [attr, tag] = await Promise.all([
+        context.env.getConfiguration?.('vue.complete.casing.props', uri),
+        context.env.getConfiguration?.('vue.complete.casing.tags', uri),
+    ]);
+    const tagNameCasing = detected.tag.length === 1 && (tag === 'autoPascal' || tag === 'autoKebab') ? detected.tag[0] : (tag === 'autoKebab' || tag === 'kebab') ? types_1.TagNameCasing.Kebab : types_1.TagNameCasing.Pascal;
+    const attrNameCasing = detected.attr.length === 1 && (attr === 'autoCamel' || attr === 'autoKebab') ? detected.attr[0] : (attr === 'autoCamel' || attr === 'camel') ? types_1.AttrNameCasing.Camel : types_1.AttrNameCasing.Kebab;
+    return {
+        tag: tagNameCasing,
+        attr: attrNameCasing,
+    };
+}
+exports.getNameCasing = getNameCasing;
+async function detect(context, uri) {
+    const rootFile = context.language.files.get(uri)?.generated?.code;
+    if (!(rootFile instanceof language_core_1.VueGeneratedCode)) {
+        return {
+            tag: [],
+            attr: [],
+        };
+    }
+    return {
+        tag: await getTagNameCase(rootFile),
+        attr: getAttrNameCase(rootFile),
+    };
+    function getAttrNameCase(file) {
+        const tags = getTemplateTagsAndAttrs(file);
+        const result = [];
+        for (const [_, { attrs }] of tags) {
+            for (const [tagName] of attrs) {
+                // attrName
+                if (tagName !== (0, language_core_1.hyphenateTag)(tagName)) {
+                    result.push(types_1.AttrNameCasing.Camel);
+                    break;
+                }
+            }
+            for (const [tagName] of attrs) {
+                // attr-name
+                if (tagName.indexOf('-') >= 0) {
+                    result.push(types_1.AttrNameCasing.Kebab);
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    async function getTagNameCase(file) {
+        const components = await namedPipeClient.getComponentNames(file.fileName) ?? [];
+        const tagNames = getTemplateTagsAndAttrs(file);
+        const result = [];
+        let anyComponentUsed = false;
+        for (const component of components) {
+            if (tagNames.has(component) || tagNames.has((0, language_core_1.hyphenateTag)(component))) {
+                anyComponentUsed = true;
+                break;
+            }
+        }
+        if (!anyComponentUsed) {
+            return []; // not sure component style, because do not have any component using in <template> for check
+        }
+        for (const [tagName] of tagNames) {
+            // TagName
+            if (tagName !== (0, language_core_1.hyphenateTag)(tagName)) {
+                result.push(types_1.TagNameCasing.Pascal);
+                break;
+            }
+        }
+        for (const component of components) {
+            // Tagname -> tagname
+            // TagName -> tag-name
+            if (component !== (0, language_core_1.hyphenateTag)(component) && tagNames.has((0, language_core_1.hyphenateTag)(component))) {
+                result.push(types_1.TagNameCasing.Kebab);
+                break;
+            }
+        }
+        return result;
+    }
+}
+exports.detect = detect;
+const map = new WeakMap();
+function getTemplateTagsAndAttrs(sourceFile) {
+    if (!map.has(sourceFile)) {
+        const getter = (0, computeds_1.computed)(() => {
+            if (!(sourceFile instanceof vue.VueGeneratedCode))
+                return;
+            const ast = sourceFile.sfc.template?.ast;
+            const tags = new Map();
+            if (ast) {
+                for (const node of vue.eachElementNode(ast)) {
+                    if (!tags.has(node.tag)) {
+                        tags.set(node.tag, { offsets: [], attrs: new Map() });
+                    }
+                    const tag = tags.get(node.tag);
+                    const startTagHtmlOffset = node.loc.start.offset + node.loc.source.indexOf(node.tag);
+                    const endTagHtmlOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
+                    tag.offsets.push(startTagHtmlOffset);
+                    if (!node.isSelfClosing) {
+                        tag.offsets.push(endTagHtmlOffset);
+                    }
+                    for (const prop of node.props) {
+                        let name;
+                        let offset;
+                        if (prop.type === 7
+                            && prop.arg?.type === 4
+                            && prop.arg.isStatic) {
+                            name = prop.arg.content;
+                            offset = prop.arg.loc.start.offset;
+                        }
+                        else if (prop.type === 6) {
+                            name = prop.name;
+                            offset = prop.loc.start.offset;
+                        }
+                        if (name !== undefined && offset !== undefined) {
+                            if (!tag.attrs.has(name)) {
+                                tag.attrs.set(name, { offsets: [] });
+                            }
+                            tag.attrs.get(name).offsets.push(offset);
+                        }
+                    }
+                }
+            }
+            return tags;
+        });
+        map.set(sourceFile, getter);
+    }
+    return map.get(sourceFile)() ?? new Map();
+}
+//# sourceMappingURL=nameCasing.js.map

package/lib/plugins/css.d.ts

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

package/lib/plugins/css.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const volar_service_css_1 = require("volar-service-css");
+function create() {
+    const base = (0, volar_service_css_1.create)({ scssDocumentSelector: ['scss', 'postcss'] });
+    return {
+        ...base,
+        create(context) {
+            const baseInstance = base.create(context);
+            return {
+                ...baseInstance,
+                async provideDiagnostics(document, token) {
+                    let diagnostics = await baseInstance.provideDiagnostics?.(document, token) ?? [];
+                    if (document.languageId === 'postcss') {
+                        diagnostics = diagnostics.filter(diag => diag.code !== 'css-semicolonexpected');
+                        diagnostics = diagnostics.filter(diag => diag.code !== 'css-ruleorselectorexpected');
+                        diagnostics = diagnostics.filter(diag => diag.code !== 'unknownAtRules');
+                    }
+                    return diagnostics;
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+//# sourceMappingURL=css.js.map

package/lib/plugins/data.d.ts

@@ -0,0 +1,4 @@
+import type * as html from 'vscode-html-languageservice';
+export declare function loadTemplateData(lang: string): html.HTMLDataV1;
+export declare function loadLanguageBlocks(lang: string): html.HTMLDataV1;
+export declare function loadModelModifiersData(lang: string): html.HTMLDataV1;

package/lib/plugins/data.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModelModifiersData = exports.loadLanguageBlocks = exports.loadTemplateData = void 0;
+function loadTemplateData(lang) {
+    lang = lang.toLowerCase();
+    let data;
+    if (lang === 'ja') {
+        data = require('../../data/template/ja.json');
+    }
+    else if (lang === 'fr') {
+        data = require('../../data/template/fr.json');
+    }
+    else if (lang === 'ko') {
+        data = require('../../data/template/ko.json');
+    }
+    else if (lang === 'pt-br') {
+        data = require('../../data/template/pt.json');
+    }
+    else if (lang === 'zh-cn') {
+        data = require('../../data/template/zh-cn.json');
+    }
+    else if (lang === 'it') {
+        data = require('../../data/template/it.json');
+    }
+    else {
+        data = require('../../data/template/en.json');
+    }
+    for (const attr of [...data.globalAttributes ?? []]) {
+        if (!attr.name.startsWith('v-')) {
+            data.globalAttributes?.push({ ...attr, name: `:${attr.name}` });
+        }
+    }
+    const vOn = data.globalAttributes?.find(d => d.name === 'v-on');
+    const vSlot = data.globalAttributes?.find(d => d.name === 'v-slot');
+    const vBind = data.globalAttributes?.find(d => d.name === 'v-bind');
+    if (vOn)
+        data.globalAttributes?.push({ ...vOn, name: '@' });
+    if (vSlot)
+        data.globalAttributes?.push({ ...vSlot, name: '#' });
+    if (vBind)
+        data.globalAttributes?.push({ ...vBind, name: ':' });
+    return data;
+}
+exports.loadTemplateData = loadTemplateData;
+function loadLanguageBlocks(lang) {
+    lang = lang.toLowerCase();
+    if (lang === 'ja') {
+        return require('../../data/language-blocks/ja.json');
+    }
+    else if (lang === 'fr') {
+        return require('../../data/language-blocks/fr.json');
+    }
+    else if (lang === 'ko') {
+        return require('../../data/language-blocks/ko.json');
+    }
+    else if (lang === 'pt-br') {
+        return require('../../data/language-blocks/pt.json');
+    }
+    else if (lang === 'zh-cn') {
+        return require('../../data/language-blocks/zh-cn.json');
+    }
+    else if (lang === 'it') {
+        return require('../../data/language-blocks/it.json');
+    }
+    return require('../../data/language-blocks/en.json');
+}
+exports.loadLanguageBlocks = loadLanguageBlocks;
+function loadModelModifiersData(lang) {
+    lang = lang.toLowerCase();
+    if (lang === 'ja') {
+        return require('../../data/model-modifiers/ja.json');
+    }
+    else if (lang === 'fr') {
+        return require('../../data/model-modifiers/fr.json');
+    }
+    else if (lang === 'ko') {
+        return require('../../data/model-modifiers/ko.json');
+    }
+    else if (lang === 'pt-br') {
+        return require('../../data/model-modifiers/pt.json');
+    }
+    else if (lang === 'zh-cn') {
+        return require('../../data/model-modifiers/zh-cn.json');
+    }
+    else if (lang === 'it') {
+        return require('../../data/model-modifiers/it.json');
+    }
+    return require('../../data/model-modifiers/en.json');
+}
+exports.loadModelModifiersData = loadModelModifiersData;
+//# sourceMappingURL=data.js.map

package/lib/plugins/vue-autoinsert-dotvalue.d.ts

@@ -0,0 +1,10 @@
+import type { ServicePlugin } from '@volar/language-service';
+import type * as ts from 'typescript';
+import type * as vscode from 'vscode-languageserver-protocol';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function create(ts: typeof import('typescript')): ServicePlugin;
+export declare function isCharacterTyping(document: TextDocument, lastChange: {
+    range: vscode.Range;
+    text: string;
+}): boolean;
+export declare function isBlacklistNode(ts: typeof import('typescript'), node: ts.Node, pos: number, allowAccessDotValue: boolean): boolean;

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBlacklistNode = exports.isCharacterTyping = exports.create = void 0;
+const language_core_1 = require("@vue/language-core");
+const namedPipeClient = require("@vue/typescript-plugin/lib/client");
+const asts = new WeakMap();
+function getAst(ts, fileName, snapshot, scriptKind) {
+    let ast = asts.get(snapshot);
+    if (!ast) {
+        ast = ts.createSourceFile(fileName, snapshot.getText(0, snapshot.getLength()), ts.ScriptTarget.Latest, undefined, scriptKind);
+        asts.set(snapshot, ast);
+    }
+    return ast;
+}
+function create(ts) {
+    return {
+        name: 'vue-autoinsert-dotvalue',
+        create(context) {
+            let currentReq = 0;
+            return {
+                async provideAutoInsertionEdit(document, position, lastChange) {
+                    if (!isTsDocument(document))
+                        return;
+                    if (!isCharacterTyping(document, lastChange))
+                        return;
+                    const req = ++currentReq;
+                    // Wait for tsserver to sync
+                    await sleep(250);
+                    if (req !== currentReq)
+                        return;
+                    const enabled = await context.env.getConfiguration?.('vue.autoInsert.dotValue') ?? true;
+                    if (!enabled)
+                        return;
+                    const [code, file] = context.documents.getVirtualCodeByUri(document.uri);
+                    if (!file)
+                        return;
+                    let ast;
+                    let sourceCodeOffset = document.offsetAt(position);
+                    const fileName = context.env.typescript.uriToFileName(file.id);
+                    if (file?.generated) {
+                        const script = file.generated.languagePlugin.typescript?.getScript(file.generated.code);
+                        if (script?.code !== code) {
+                            return;
+                        }
+                        ast = getAst(ts, fileName, script.code.snapshot, script.scriptKind);
+                        let mapped = false;
+                        for (const [_1, [_2, map]] of context.language.files.getMaps(code)) {
+                            const sourceOffset = map.getSourceOffset(document.offsetAt(position));
+                            if (sourceOffset !== undefined) {
+                                sourceCodeOffset = sourceOffset[0];
+                                mapped = true;
+                                break;
+                            }
+                        }
+                        if (!mapped) {
+                            return;
+                        }
+                    }
+                    else {
+                        ast = getAst(ts, fileName, file.snapshot);
+                    }
+                    if (isBlacklistNode(ts, ast, document.offsetAt(position), false))
+                        return;
+                    const props = await namedPipeClient.getPropertiesAtLocation(fileName, sourceCodeOffset) ?? [];
+                    if (props.some(prop => prop === 'value')) {
+                        return '${1:.value}';
+                    }
+                },
+            };
+        },
+    };
+}
+exports.create = create;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function isTsDocument(document) {
+    return document.languageId === 'javascript' ||
+        document.languageId === 'typescript' ||
+        document.languageId === 'javascriptreact' ||
+        document.languageId === 'typescriptreact';
+}
+const charReg = /\w/;
+function isCharacterTyping(document, lastChange) {
+    const lastCharacter = lastChange.text[lastChange.text.length - 1];
+    const rangeStart = lastChange.range.start;
+    const position = {
+        line: rangeStart.line,
+        character: rangeStart.character + lastChange.text.length,
+    };
+    const nextCharacter = document.getText({
+        start: position,
+        end: { line: position.line, character: position.character + 1 },
+    });
+    if (lastCharacter === undefined) { // delete text
+        return false;
+    }
+    if (lastChange.text.indexOf('\n') >= 0) { // multi-line change
+        return false;
+    }
+    return charReg.test(lastCharacter) && !charReg.test(nextCharacter);
+}
+exports.isCharacterTyping = isCharacterTyping;
+function isBlacklistNode(ts, node, pos, allowAccessDotValue) {
+    if (ts.isVariableDeclaration(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isFunctionDeclaration(node) && node.name && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isParameter(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isPropertyAssignment(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isShorthandPropertyAssignment(node)) {
+        return true;
+    }
+    else if (ts.isImportDeclaration(node)) {
+        return true;
+    }
+    else if (ts.isLiteralTypeNode(node)) {
+        return true;
+    }
+    else if (ts.isTypeReferenceNode(node)) {
+        return true;
+    }
+    else if (!allowAccessDotValue && ts.isPropertyAccessExpression(node) && node.expression.end === pos && node.name.text === 'value') {
+        return true;
+    }
+    else if (ts.isCallExpression(node)
+        && ts.isIdentifier(node.expression)
+        && isWatchOrUseFunction(node.expression.text)
+        && isTopLevelArgOrArrayTopLevelItemItem(node)) {
+        return true;
+    }
+    else {
+        let _isBlacklistNode = false;
+        node.forEachChild(node => {
+            if (_isBlacklistNode)
+                return;
+            if (pos >= node.getFullStart() && pos <= node.getEnd()) {
+                if (isBlacklistNode(ts, node, pos, allowAccessDotValue)) {
+                    _isBlacklistNode = true;
+                }
+            }
+        });
+        return _isBlacklistNode;
+    }
+    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);
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+    }
+}
+exports.isBlacklistNode = isBlacklistNode;
+//# sourceMappingURL=vue-autoinsert-dotvalue.js.map

package/lib/plugins/vue-autoinsert-parentheses.d.ts

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