@vue/language-core 2.2.4 → 2.2.8

package/lib/parsers/scriptSetupRanges.js

@@ -74,91 +74,48 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         if (ts.isCallExpression(node)
             && ts.isIdentifier(node.expression)) {
             const callText = _getNodeText(node.expression);
-            if (vueCompilerOptions.macros.defineModel.includes(callText)) {
+            const isDefineModel = vueCompilerOptions.macros.defineModel.includes(callText);
+            if (isDefineModel || callText === 'defineProp') {
                 let localName;
                 let propName;
                 let options;
+                let type;
+                let modifierType;
+                let runtimeType;
+                let defaultValue;
+                let required = false;
                 if (ts.isVariableDeclaration(parent) &&
                     ts.isIdentifier(parent.name)) {
                     localName = _getStartEnd(parent.name);
                 }
-                if (node.arguments.length >= 2) {
-                    propName = _getStartEnd(node.arguments[0]);
-                    options = node.arguments[1];
-                }
-                else if (node.arguments.length >= 1) {
-                    if (ts.isStringLiteralLike(node.arguments[0])) {
-                        propName = _getStartEnd(node.arguments[0]);
+                if (node.typeArguments) {
+                    if (node.typeArguments.length >= 1) {
+                        type = _getStartEnd(node.typeArguments[0]);
                     }
-                    else {
-                        options = node.arguments[0];
+                    if (node.typeArguments.length >= 2) {
+                        modifierType = _getStartEnd(node.typeArguments[1]);
                     }
                 }
-                let runtimeType;
-                let defaultValue;
-                let required = false;
-                if (options && ts.isObjectLiteralExpression(options)) {
-                    for (const property of options.properties) {
-                        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                            continue;
-                        }
-                        const text = _getNodeText(property.name);
-                        if (text === 'type') {
-                            runtimeType = _getStartEnd(property.initializer);
-                        }
-                        else if (text === 'default') {
-                            defaultValue = _getStartEnd(property.initializer);
+                if (isDefineModel) {
+                    if (node.arguments.length >= 2) {
+                        propName = node.arguments[0];
+                        options = node.arguments[1];
+                    }
+                    else if (node.arguments.length >= 1) {
+                        if (ts.isStringLiteralLike(node.arguments[0])) {
+                            propName = node.arguments[0];
                         }
-                        else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-                            required = true;
+                        else {
+                            options = node.arguments[0];
                         }
                     }
                 }
-                defineProp.push({
-                    localName,
-                    name: propName,
-                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
-                    modifierType: node.typeArguments && node.typeArguments?.length >= 2 ? _getStartEnd(node.typeArguments[1]) : undefined,
-                    runtimeType,
-                    defaultValue,
-                    required,
-                    isModel: true,
-                });
-            }
-            else if (callText === 'defineProp') {
-                let localName;
-                let propName;
-                let options;
-                if (ts.isVariableDeclaration(parent) &&
-                    ts.isIdentifier(parent.name)) {
-                    localName = _getStartEnd(parent.name);
-                }
-                let runtimeType;
-                let defaultValue;
-                let required = false;
-                if (definePropProposalA) {
+                else if (definePropProposalA) {
                     if (node.arguments.length >= 2) {
                         options = node.arguments[1];
                     }
                     if (node.arguments.length >= 1) {
-                        propName = _getStartEnd(node.arguments[0]);
-                    }
-                    if (options && ts.isObjectLiteralExpression(options)) {
-                        for (const property of options.properties) {
-                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                                continue;
-                            }
-                            const text = _getNodeText(property.name);
-                            if (text === 'type') {
-                                runtimeType = _getStartEnd(property.initializer);
-                            }
-                            else if (text === 'default') {
-                                defaultValue = _getStartEnd(property.initializer);
-                            }
-                            else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-                                required = true;
-                            }
-                        }
+                        propName = node.arguments[0];
                     }
                 }
                 else if (definePropProposalB) {
@@ -173,25 +130,39 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     if (node.arguments.length >= 1) {
                         defaultValue = _getStartEnd(node.arguments[0]);
                     }
-                    if (options && ts.isObjectLiteralExpression(options)) {
-                        for (const property of options.properties) {
-                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                                continue;
-                            }
-                            const text = _getNodeText(property.name);
-                            if (text === 'type') {
-                                runtimeType = _getStartEnd(property.initializer);
-                            }
+                }
+                if (options && ts.isObjectLiteralExpression(options)) {
+                    for (const property of options.properties) {
+                        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                            continue;
+                        }
+                        const text = _getNodeText(property.name);
+                        if (text === 'type') {
+                            runtimeType = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'default') {
+                            defaultValue = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
                         }
                     }
                 }
+                let name;
+                if (propName && ts.isStringLiteralLike(propName)) {
+                    name = _getStartEnd(propName);
+                }
                 defineProp.push({
                     localName,
-                    name: propName,
-                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    name,
+                    type,
+                    modifierType,
                     runtimeType,
                     defaultValue,
                     required,
+                    isModel: isDefineModel,
+                    comments: getCommentsRange(ts, node, parents, ast),
+                    argNode: options,
                 });
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
@@ -451,4 +422,19 @@ function getStatementRange(ts, parents, node, ast) {
     }
     return statementRange;
 }
+function getCommentsRange(ts, node, parents, ast) {
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(node)) {
+            break;
+        }
+        node = parents[i];
+    }
+    const comments = ts.getLeadingCommentRanges(ast.text, node.pos);
+    if (comments?.length) {
+        return {
+            start: comments[0].pos,
+            end: comments.at(-1).end,
+        };
+    }
+}
 //# sourceMappingURL=scriptSetupRanges.js.map

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

@@ -1,4 +1,3 @@
-import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
     getScriptRanges: () => {
@@ -38,6 +37,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
             defaultValue?: import("../types").TextRange;
             required?: boolean;
             isModel?: boolean;
+            comments?: import("../types").TextRange;
+            argNode?: import("typescript").Expression;
         }[];
         defineProps: ({
             callExp: import("../types").TextRange;
@@ -118,10 +119,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getLang: () => string;
     getGeneratedScript: () => {
         codes: Code[];
-        linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
         generatedPropsType: boolean;
-        scriptSetupGeneratedOffset: number | undefined;
         bypassDefineComponent: boolean;
         bindingNames: Set<string>;
         localTypes: {

package/lib/plugins/vue-tsx.js

@@ -35,7 +35,6 @@ const plugin = ctx => {
                 const tsx = codegen.getGeneratedScript();
                 if (tsx) {
                     embeddedFile.content = [...tsx.codes];
-                    embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
                 }
             }
         },
@@ -168,8 +167,6 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
         };
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
-        const linkedCodeMappings = [];
-        let generatedLength = 0;
         const codes = [];
         const codegen = (0, script_1.generateScript)({
             ts,
@@ -184,8 +181,6 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
             templateCodegen: getGeneratedTemplate(),
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
-            getGeneratedLength: () => generatedLength,
-            linkedCodeMappings,
             appendGlobalTypes,
         });
         fileEditTimes.set(fileName, (fileEditTimes.get(fileName) ?? 0) + 1);
@@ -193,15 +188,11 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
         while (!current.done) {
             const code = current.value;
             codes.push(code);
-            generatedLength += typeof code === 'string'
-                ? code.length
-                : code[0].length;
             current = codegen.next();
         }
         return {
             ...current.value,
             codes,
-            linkedCodeMappings,
         };
     });
     return {

package/lib/types.d.ts

@@ -13,6 +13,7 @@ export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' |
 };
 export interface VueCodeInformation extends CodeInformation {
     __combineOffset?: number;
+    __linkedToken?: symbol;
 }
 export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {

package/lib/virtualFile/computedEmbeddedCodes.js

@@ -171,6 +171,7 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByN
                 ];
             }));
             const newMappings = [];
+            const tokenMappings = new Map();
             for (let i = 0; i < mappings.length; i++) {
                 const mapping = mappings[i];
                 if (mapping.data.__combineOffset !== undefined) {
@@ -183,6 +184,22 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByN
                     offsetMapping.lengths.push(...mapping.lengths);
                     continue;
                 }
+                if (mapping.data.__linkedToken !== undefined) {
+                    const token = mapping.data.__linkedToken;
+                    if (tokenMappings.has(token)) {
+                        const prevMapping = tokenMappings.get(token);
+                        code.linkedCodeMappings.push({
+                            sourceOffsets: [prevMapping.generatedOffsets[0]],
+                            generatedOffsets: [mapping.generatedOffsets[0]],
+                            lengths: [Number(token.description)],
+                            data: undefined,
+                        });
+                    }
+                    else {
+                        tokenMappings.set(token, mapping);
+                    }
+                    continue;
+                }
                 newMappings.push(mapping);
             }
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.2.4",
+	"version": "2.2.8",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "c28986596935cb43979c9d437c25f292bdb36cef"
+	"gitHead": "cdf00e6f19971260607ea2347924b94126a254fc"
 }