@vue/language-core 2.2.0 → 2.2.4

package/lib/parsers/scriptSetupRanges.js

@@ -196,25 +196,21 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 defineProps = {
-                    ...parseCallExpression(node),
-                    statement: getStatementRange(ts, parents, node, ast)
+                    ...parseCallExpressionAssignment(node, parent),
+                    statement: getStatementRange(ts, parents, node, ast),
+                    argNode: node.arguments[0]
                 };
-                if (ts.isVariableDeclaration(parent)) {
-                    if (ts.isObjectBindingPattern(parent.name)) {
-                        defineProps.destructured = new Set();
-                        const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
-                        for (const [id, isRest] of identifiers) {
-                            const name = _getNodeText(id);
-                            if (isRest) {
-                                defineProps.destructuredRest = name;
-                            }
-                            else {
-                                defineProps.destructured.add(name);
-                            }
+                if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
+                    defineProps.destructured = new Map();
+                    const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
+                    for (const { id, isRest, initializer } of identifiers) {
+                        const name = _getNodeText(id);
+                        if (isRest) {
+                            defineProps.destructuredRest = name;
+                        }
+                        else {
+                            defineProps.destructured.set(name, initializer);
                         }
-                    }
-                    else {
-                        defineProps.name = _getNodeText(parent.name);
                     }
                 }
                 else if (ts.isCallExpression(parent)
@@ -230,17 +226,15 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 withDefaults = {
                     callExp: _getStartEnd(node),
                     exp: _getStartEnd(node.expression),
-                    arg: arg ? _getStartEnd(arg) : undefined
+                    arg: arg ? _getStartEnd(arg) : undefined,
+                    argNode: arg
                 };
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
                 defineEmits = {
-                    ...parseCallExpression(node),
+                    ...parseCallExpressionAssignment(node, parent),
                     statement: getStatementRange(ts, parents, node, ast)
                 };
-                if (ts.isVariableDeclaration(parent)) {
-                    defineEmits.name = _getNodeText(parent.name);
-                }
                 if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
                     for (const member of node.typeArguments[0].members) {
                         if (ts.isCallSignatureDeclaration(member)) {
@@ -255,17 +249,9 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 defineSlots = {
-                    ...parseCallExpression(node),
+                    ...parseCallExpressionAssignment(node, parent),
                     statement: getStatementRange(ts, parents, node, ast)
                 };
-                if (ts.isVariableDeclaration(parent)) {
-                    if (ts.isIdentifier(parent.name)) {
-                        defineSlots.name = _getNodeText(parent.name);
-                    }
-                    else {
-                        defineSlots.isObjectBindingPattern = ts.isObjectBindingPattern(parent.name);
-                    }
-                }
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
                 defineExpose = parseCallExpression(node);
@@ -298,10 +284,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.composables.useTemplateRef.includes(callText)
                 && !node.typeArguments?.length) {
-                useTemplateRef.push({
-                    name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
-                    ...parseCallExpression(node)
-                });
+                useTemplateRef.push(parseCallExpressionAssignment(node, parent));
             }
         }
         ts.forEachChild(node, child => {
@@ -321,6 +304,12 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
         };
     }
+    function parseCallExpressionAssignment(node, parent) {
+        return {
+            name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
+            ...parseCallExpression(node),
+        };
+    }
     function _getStartEnd(node) {
         return getStartEnd(ts, node, ast);
     }

package/lib/parsers/vueCompilerOptions.d.ts

@@ -1,2 +1,2 @@
-import type { VueCompilerOptions } from '../types';
-export declare function parseVueCompilerOptions(comments: string[]): Partial<VueCompilerOptions> | undefined;
+import type { RawVueCompilerOptions } from '../types';
+export declare function parseVueCompilerOptions(comments: string[]): RawVueCompilerOptions | undefined;

package/lib/plugins/file-md.js

@@ -6,6 +6,7 @@ const buildMappings_1 = require("../utils/buildMappings");
 const parseSfc_1 = require("../utils/parseSfc");
 const codeblockReg = /(`{3,})[\s\S]+?\1/g;
 const inlineCodeblockReg = /`[^\n`]+?`/g;
+const latexBlockReg = /(\${2,})[\s\S]+?\1/g;
 const scriptSetupReg = /\\\<[\s\S]+?\>\n?/g;
 const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
 const angleBracketReg = /\<\S*\:\S*\>/g;
@@ -31,6 +32,8 @@ const plugin = ({ vueCompilerOptions }) => {
                 .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
                 // inline code block
                 .replace(inlineCodeblockReg, match => `\`${' '.repeat(match.length - 2)}\``)
+                // latex block
+                .replace(latexBlockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
                 // # \<script setup>
                 .replace(scriptSetupReg, match => ' '.repeat(match.length))
                 // <<< https://vitepress.dev/guide/markdown#import-code-snippets

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

@@ -60,10 +60,10 @@ const plugin = ctx => {
         return data;
         function visit(node) {
             if (node.type === CompilerDOM.NodeTypes.COMMENT) {
-                const match = node.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
+                const match = node.loc.source.match(/^<!--\s*@vue-generic\s*\{(?<content>[\s\S]*)\}\s*-->$/);
                 if (match) {
-                    const { content } = match.groups ?? {};
-                    addFormatCodes(content, node.loc.start.offset + match[0].indexOf(content), formatBrackets.generic);
+                    const { content } = match.groups;
+                    addFormatCodes(content, node.loc.start.offset + node.loc.source.indexOf('{') + 1, formatBrackets.generic);
                 }
             }
             else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
@@ -76,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, utils_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);
+                            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);
                         }
                     }
                 }
@@ -100,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);
@@ -111,8 +129,14 @@ 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;
+                    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) {
@@ -135,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").Computed<{
+    getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -19,8 +19,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
             isDefaultImport?: boolean;
             isNamespace?: boolean;
         }[];
-    } | undefined>;
-    scriptSetupRanges: import("alien-signals").Computed<{
+    } | undefined;
+    getScriptSetupRanges: () => {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: {
@@ -46,15 +46,19 @@ export declare const tsCodegen: WeakMap<Sfc, {
             typeArg?: import("../types").TextRange;
         } & {
             name?: string;
-            destructured?: Set<string>;
+            destructured?: Map<string, import("typescript").Expression | undefined>;
             destructuredRest?: string;
             statement: import("../types").TextRange;
+            argNode?: import("typescript").Expression;
         }) | undefined;
-        withDefaults: {
+        withDefaults: (Omit<{
             callExp: import("../types").TextRange;
             exp: import("../types").TextRange;
-            arg?: import("../types").TextRange | undefined;
-        } | undefined;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        }, "typeArg"> & {
+            argNode?: import("typescript").Expression;
+        }) | undefined;
         defineEmits: ({
             callExp: import("../types").TextRange;
             exp: import("../types").TextRange;
@@ -72,7 +76,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             typeArg?: import("../types").TextRange;
         } & {
             name?: string;
-            isObjectBindingPattern?: boolean;
             statement: import("../types").TextRange;
         }) | undefined;
         defineExpose: {
@@ -111,9 +114,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
         } & {
             name?: string;
         })[];
-    } | undefined>;
-    lang: import("alien-signals").Computed<string>;
-    generatedScript: import("alien-signals").Computed<{
+    } | undefined;
+    getLang: () => string;
+    getGeneratedScript: () => {
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
@@ -127,46 +130,51 @@ 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").Computed<{
+    };
+    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;
+        }[];
+        dollarVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
         lastGenericComment: {
             content: string;
             offset: number;
         } | undefined;
-        hasSlotElements: Set<import("@vue/compiler-dom").ElementNode>;
         blockConditions: string[];
         scopedClasses: {
             source: string;
@@ -175,27 +183,30 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         emptyClassOffsets: number[];
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
-        hasSlot: boolean;
         bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
         inheritedAttrVars: Set<string>;
-        templateRefs: Map<string, [varName: string, offset: number]>;
+        templateRefs: Map<string, {
+            typeExp: string;
+            offset: number;
+        }>;
         currentComponent: {
-            node: import("@vue/compiler-dom").ElementNode;
             ctxVar: string;
             used: boolean;
         } | undefined;
-        singleRootElType: string | undefined;
-        singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
+        singleRootElTypes: string[];
+        singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         accessExternalVariable(name: string, offset?: number): void;
         hasLocalVariable: (name: string) => boolean;
         addLocalVariable: (name: string) => void;
         removeLocalVariable: (name: string) => void;
         getInternalVariable: () => string;
+        getHoistVariable: (originalVar: string) => string;
+        generateHoistVariables: () => Generator<string, void, unknown>;
         ignoreError: () => Generator<Code>;
         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;