@vue/language-core 2.1.10 → 2.2.2

package/lib/plugins/vue-style-class-names.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commentReg = void 0;
+exports.fillBlank = fillBlank;
+exports.commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const fragmentReg = /(?<={)[^{]*(?=(?<!\\);)/g;
+const plugin = () => {
+    return {
+        version: 2.1,
+        resolveStyleReferenceLinks(block) {
+            const result = [];
+            const content = fillBlank(block.content, exports.commentReg, fragmentReg);
+            const matches = content.matchAll(cssClassNameReg);
+            for (const match of matches) {
+                const matchText = match[1];
+                if (matchText) {
+                    result.push({ text: matchText, offset: match.index });
+                }
+            }
+            return result;
+        },
+    };
+};
+exports.default = plugin;
+function fillBlank(css, ...regs) {
+    for (const reg of regs) {
+        css = css.replace(reg, match => ' '.repeat(match.length));
+    }
+    return css;
+}
+//# sourceMappingURL=vue-style-class-names.js.map

package/lib/plugins/vue-style-reference-link.d.ts

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

package/lib/plugins/vue-style-reference-link.js

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

package/lib/plugins/vue-style-reference-links.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-style-reference-links.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+const plugin = () => {
+    return {
+        version: 2.1,
+        resolveStyleReferenceLinks(block) {
+            const result = [];
+            const matches = block.content.matchAll(cssImportReg);
+            for (const match of matches) {
+                let text = match[0];
+                let offset = match.index;
+                if (text.startsWith('\'') || text.startsWith('"')) {
+                    text = text.slice(1, -1);
+                    offset += 1;
+                }
+                if (text) {
+                    result.push({ text, offset });
+                }
+            }
+            return result;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-style-reference-links.js.map

package/lib/plugins/vue-template-html.js

@@ -155,6 +155,10 @@ const plugin = ({ modules }) => {
                             if (node.isStatic) {
                                 return false;
                             }
+                            else if (!node.loc.source) {
+                                // :class="..." -> :class=""
+                                return false;
+                            }
                             else {
                                 node.content = node.loc.source;
                             }
@@ -168,9 +172,9 @@ const plugin = ({ modules }) => {
                 delete loc.__endOffset;
                 if (withinChangeRange(loc)) {
                     loc.source =
-                        loc.source.substring(0, change.start - loc.start.offset)
+                        loc.source.slice(0, change.start - loc.start.offset)
                             + change.newText
-                            + loc.source.substring(change.end - loc.start.offset);
+                            + loc.source.slice(change.end - loc.start.offset);
                     loc.__endOffset = loc.end.offset;
                     loc.end.offset += lengthDiff;
                     return true;

package/lib/plugins/vue-template-inline-css.js

@@ -39,7 +39,7 @@ function* generate(templateAst) {
                 const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
                 const start = prop.arg.loc.source.indexOf(endCrt) + 1;
                 const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.substring(start, end);
+                const content = prop.arg.loc.source.slice(start, end);
                 yield `x { `;
                 yield [
                     content,

package/lib/plugins/vue-template-inline-ts.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("../codegen/common");
+const CompilerDOM = require("@vue/compiler-dom");
 const elementEvents_1 = require("../codegen/template/elementEvents");
 const templateChild_1 = require("../codegen/template/templateChild");
 const vFor_1 = require("../codegen/template/vFor");
-const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../codegen/utils");
 const codeFeatures = {
     format: true,
 };
@@ -18,6 +18,7 @@ const formatBrackets = {
     // fix https://github.com/vuejs/language-tools/issues/2305
     curly: ['0 +', '+ 0;'],
     event: ['() => ', ';'],
+    generic: ['<', '>() => {};'],
 };
 const plugin = ctx => {
     const parseds = new WeakMap();
@@ -58,7 +59,14 @@ const plugin = ctx => {
         sfc.template.ast.children.forEach(visit);
         return data;
         function visit(node) {
-            if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+            if (node.type === CompilerDOM.NodeTypes.COMMENT) {
+                const match = node.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
+                if (match) {
+                    const { content } = match.groups ?? {};
+                    addFormatCodes(content, node.loc.start.offset + match[0].indexOf(content), formatBrackets.generic);
+                }
+            }
+            else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
                 for (const prop of node.props) {
                     if (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE) {
                         continue;
@@ -68,19 +76,37 @@ const plugin = ctx => {
                         continue;
                     }
                     if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && !prop.arg.isStatic) {
-                        addFormatCodes(prop.arg.content, prop.arg.loc.start.offset, formatBrackets.normal);
+                        addFormatCodes(prop.arg.loc.source, prop.arg.loc.start.offset, formatBrackets.normal);
                     }
                     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                         && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY // style='z-index: 2' will compile to {'z-index':'2'}
                     ) {
                         if (prop.name === 'on' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                            const ast = (0, common_1.createTsAst)(ctx.modules.typescript, prop.exp, prop.exp.content);
-                            addFormatCodes(prop.exp.content, prop.exp.loc.start.offset, (0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)
-                                ? formatBrackets.event
-                                : formatBrackets.normal);
+                            const ast = (0, utils_1.createTsAst)(ctx.modules.typescript, prop.exp, prop.exp.content);
+                            if ((0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)) {
+                                addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.event);
+                            }
+                            else {
+                                const lines = prop.exp.content.split('\n');
+                                const firstLineEmpty = lines[0].trim() === '';
+                                const lastLineEmpty = lines[lines.length - 1].trim() === '';
+                                if (lines.length <= 1 || (!firstLineEmpty && !lastLineEmpty)) {
+                                    addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
+                                }
+                                else {
+                                    addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, ['(', ');']);
+                                }
+                            }
+                        }
+                        else if (prop.name === 'slot') {
+                            addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.params);
+                        }
+                        else if (prop.rawName === 'v-for') {
+                            // #2586
+                            addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.for);
                         }
                         else {
-                            addFormatCodes(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
+                            addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
                         }
                     }
                 }
@@ -92,7 +118,7 @@ const plugin = ctx => {
                 for (let i = 0; i < node.branches.length; i++) {
                     const branch = node.branches[i];
                     if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                        addFormatCodes(branch.condition.content, branch.condition.loc.start.offset, formatBrackets.if);
+                        addFormatCodes(branch.condition.loc.source, branch.condition.loc.start.offset, formatBrackets.if);
                     }
                     for (const childNode of branch.children) {
                         visit(childNode);
@@ -103,9 +129,15 @@ const plugin = ctx => {
                 const { leftExpressionRange, leftExpressionText } = (0, vFor_1.parseVForNode)(node);
                 const { source } = node.parseResult;
                 if (leftExpressionRange && leftExpressionText && source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                    const start = leftExpressionRange.start;
-                    const end = source.loc.start.offset + source.content.length;
-                    addFormatCodes(templateContent.substring(start, end), start, formatBrackets.for);
+                    let start = leftExpressionRange.start;
+                    let end = source.loc.start.offset + source.content.length;
+                    while (templateContent[start - 1] === ' ' || templateContent[start - 1] === '(') {
+                        start--;
+                    }
+                    while (templateContent[end] === ' ' || templateContent[end] === ')') {
+                        end++;
+                    }
+                    addFormatCodes(templateContent.slice(start, end), start, formatBrackets.for);
                 }
                 for (const child of node.children) {
                     visit(child);
@@ -127,10 +159,27 @@ const plugin = ctx => {
                 // {{ ... }}
                 const [content, start] = (0, templateChild_1.parseInterpolationNode)(node, templateContent);
                 const lines = content.split('\n');
-                addFormatCodes(content, start, lines.length <= 1 ? formatBrackets.curly : [
-                    lines[0].trim() === '' ? '(' : formatBrackets.curly[0],
-                    lines[lines.length - 1].trim() === '' ? ');' : formatBrackets.curly[1],
-                ]);
+                const firstLineEmpty = lines[0].trim() === '';
+                const lastLineEmpty = lines[lines.length - 1].trim() === '';
+                if (content.includes('=>')) { // arrow function
+                    if (lines.length <= 1 || (!firstLineEmpty && !lastLineEmpty)) {
+                        addFormatCodes(content, start, formatBrackets.normal);
+                    }
+                    else {
+                        addFormatCodes(content, start, ['(', ');']);
+                    }
+                }
+                else {
+                    if (lines.length <= 1 || (!firstLineEmpty && !lastLineEmpty)) {
+                        addFormatCodes(content, start, formatBrackets.curly);
+                    }
+                    else {
+                        addFormatCodes(content, start, [
+                            firstLineEmpty ? '(' : '(0 +',
+                            lastLineEmpty ? ');' : '+ 0);'
+                        ]);
+                    }
+                }
             }
         }
         function addFormatCodes(code, offset, wrapper) {

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

@@ -1,7 +1,7 @@
 import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    scriptRanges: import("alien-signals").ISignal<{
+    getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -13,90 +13,110 @@ export declare const tsCodegen: WeakMap<Sfc, {
             inheritAttrsOption: string | undefined;
         }) | undefined;
         classBlockEnd: number | undefined;
-        bindings: import("../types").TextRange[];
-    } | undefined>;
-    scriptSetupRanges: import("alien-signals").ISignal<{
+        bindings: {
+            range: import("../types").TextRange;
+            moduleName?: string;
+            isDefaultImport?: boolean;
+            isNamespace?: boolean;
+        }[];
+    } | undefined;
+    getScriptSetupRanges: () => {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
-        bindings: import("../types").TextRange[];
-        importComponentNames: Set<string>;
-        props: {
+        bindings: {
+            range: import("../types").TextRange;
+            moduleName?: string;
+            isDefaultImport?: boolean;
+            isNamespace?: boolean;
+        }[];
+        defineProp: {
+            localName?: import("../types").TextRange;
+            name?: import("../types").TextRange;
+            type?: import("../types").TextRange;
+            modifierType?: import("../types").TextRange;
+            runtimeType?: import("../types").TextRange;
+            defaultValue?: import("../types").TextRange;
+            required?: boolean;
+            isModel?: boolean;
+        }[];
+        defineProps: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
             name?: string;
-            destructured?: Set<string>;
+            destructured?: Map<string, import("typescript").Expression | undefined>;
             destructuredRest?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }> & {
-                statement: import("../types").TextRange;
-            };
-            withDefaults?: import("../types").TextRange & {
-                arg?: import("../types").TextRange;
-            };
-        };
-        slots: {
-            name?: string;
-            isObjectBindingPattern?: boolean;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }> & {
-                statement: import("../types").TextRange;
-            };
-        };
-        emits: {
+            statement: import("../types").TextRange;
+            argNode?: import("typescript").Expression;
+        }) | undefined;
+        withDefaults: (Omit<{
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        }, "typeArg"> & {
+            argNode?: import("typescript").Expression;
+        }) | undefined;
+        defineEmits: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
             name?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }> & {
-                statement: import("../types").TextRange;
-                hasUnionTypeArg?: boolean;
-            };
-        };
-        expose: {
+            hasUnionTypeArg?: boolean;
+            statement: import("../types").TextRange;
+        }) | undefined;
+        defineSlots: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
             name?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
-        };
-        options: {
+            statement: import("../types").TextRange;
+        }) | undefined;
+        defineExpose: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } | undefined;
+        defineOptions: {
             name?: string;
             inheritAttrs?: string;
-        };
-        cssModules: {
-            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
+        } | undefined;
+        useAttrs: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
         }[];
-        defineProp: {
-            localName: import("../types").TextRange | undefined;
-            name: import("../types").TextRange | undefined;
-            type: import("../types").TextRange | undefined;
-            modifierType?: import("../types").TextRange | undefined;
-            runtimeType: import("../types").TextRange | undefined;
-            defaultValue: import("../types").TextRange | undefined;
-            required: boolean;
-            isModel?: boolean;
+        useCssModule: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
         }[];
-        templateRefs: {
-            name?: string;
-            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
+        useSlots: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
         }[];
-    } | undefined>;
-    lang: import("alien-signals").ISignal<string>;
-    generatedScript: import("alien-signals").ISignal<{
+        useTemplateRef: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
+            name?: string;
+        })[];
+    } | undefined;
+    getLang: () => string;
+    getGeneratedScript: () => {
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
@@ -110,43 +130,52 @@ export declare const tsCodegen: WeakMap<Sfc, {
             readonly PrettifyLocal: string;
             readonly OmitKeepDiscriminatedUnion: string;
             readonly WithDefaults: string;
-            readonly WithTemplateSlots: string;
+            readonly WithSlots: string;
             readonly PropsChildren: string;
             readonly TypePropsToOption: string;
             readonly OmitIndexSignature: string;
         };
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
-    }>;
-    generatedTemplate: import("alien-signals").ISignal<{
+    };
+    getGeneratedTemplate: () => {
         codes: Code[];
-        slots: {
-            name: string;
-            loc?: number;
-            tagRange: [number, number];
-            varName: string;
-            nodeLoc: any;
-        }[];
-        dynamicSlots: {
-            expVar: string;
-            varName: string;
-        }[];
         codeFeatures: {
             all: import("../types").VueCodeInformation;
+            none: import("../types").VueCodeInformation;
             verification: import("../types").VueCodeInformation;
             completion: import("../types").VueCodeInformation;
             additionalCompletion: import("../types").VueCodeInformation;
+            withoutCompletion: import("../types").VueCodeInformation;
             navigation: import("../types").VueCodeInformation;
             navigationWithoutRename: import("../types").VueCodeInformation;
             navigationAndCompletion: import("../types").VueCodeInformation;
             navigationAndAdditionalCompletion: import("../types").VueCodeInformation;
+            navigationAndVerification: import("../types").VueCodeInformation;
+            withoutNavigation: import("../types").VueCodeInformation;
             withoutHighlight: import("../types").VueCodeInformation;
+            withoutHighlightAndNavigation: import("../types").VueCodeInformation;
             withoutHighlightAndCompletion: import("../types").VueCodeInformation;
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
         };
+        resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
+        slots: {
+            name: string;
+            offset?: number;
+            tagRange: [number, number];
+            nodeLoc: any;
+            propsVar: string;
+        }[];
+        dynamicSlots: {
+            expVar: string;
+            propsVar: string;
+        }[];
+        specialVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
-        hasSlotElements: Set<import("@vue/compiler-dom").ElementNode>;
+        lastGenericComment: {
+            content: string;
+            offset: number;
+        } | undefined;
         blockConditions: string[];
-        usedComponentCtxVars: Set<string>;
         scopedClasses: {
             source: string;
             className: string;
@@ -155,8 +184,13 @@ export declare const tsCodegen: WeakMap<Sfc, {
         emptyClassOffsets: number[];
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
         hasSlot: boolean;
-        inheritedAttrVars: Set<unknown>;
+        bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
+        inheritedAttrVars: Set<string>;
         templateRefs: Map<string, [varName: string, offset: number]>;
+        currentComponent: {
+            ctxVar: string;
+            used: boolean;
+        } | undefined;
         singleRootElType: string | undefined;
         singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
         accessExternalVariable(name: string, offset?: number): void;
@@ -168,7 +202,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
         resetDirectiveComments: (endStr: string) => Generator<Code>;
         generateAutoImportCompletion: () => Generator<Code>;
-    } | undefined>;
+    } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;