@vue/language-core 3.1.2 → 3.1.4

package/index.d.ts

@@ -6,6 +6,7 @@ export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
 export * from './lib/types';
 export * from './lib/utils/collectBindings';
+export * from './lib/utils/forEachTemplateNode';
 export * from './lib/utils/parseSfc';
 export * from './lib/utils/shared';
 export * from './lib/virtualFile/vueFile';

package/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
 __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/utils/collectBindings"), exports);
+__exportStar(require("./lib/utils/forEachTemplateNode"), exports);
 __exportStar(require("./lib/utils/parseSfc"), exports);
 __exportStar(require("./lib/utils/shared"), exports);
 __exportStar(require("./lib/virtualFile/vueFile"), exports);

package/lib/codegen/globalTypes.js

@@ -25,17 +25,14 @@ function generateGlobalTypes(options) {
 	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
 	const __VLS_unref: typeof import('${lib}').unref;
 	const __VLS_placeholder: any;
+	const __VLS_intrinsics: ${target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.IntrinsicElements`
+        : `globalThis.JSX.IntrinsicElements`};
 
-	type __VLS_NativeElements = __VLS_SpreadMerge<SVGElementTagNameMap, HTMLElementTagNameMap>;
-	type __VLS_IntrinsicElements = ${target >= 3.3
-        ? `import('${lib}/jsx-runtime').JSX.IntrinsicElements;`
-        : `globalThis.JSX.IntrinsicElements;`}
-	type __VLS_Element = ${target >= 3.3
-        ? `import('${lib}/jsx-runtime').JSX.Element;`
-        : `globalThis.JSX.Element;`}
+	type __VLS_Elements = __VLS_SpreadMerge<SVGElementTagNameMap, HTMLElementTagNameMap>;
 	type __VLS_GlobalComponents = ${target >= 3.5
-        ? `import('${lib}').GlobalComponents;`
-        : `import('${lib}').GlobalComponents & Pick<typeof import('${lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`}
+        ? `import('${lib}').GlobalComponents`
+        : `import('${lib}').GlobalComponents & Pick<typeof import('${lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>`};
 	type __VLS_GlobalDirectives = import('${lib}').GlobalDirectives;
 	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
 	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
@@ -57,7 +54,9 @@ function generateGlobalTypes(options) {
 		? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
 		: T extends (props: infer P, ...args: any) => any ? P
 		: {};
-	type __VLS_FunctionalComponent<T> = (props: ${fnPropsType}, ctx?: any) => __VLS_Element & {
+	type __VLS_FunctionalComponent<T> = (props: ${fnPropsType}, ctx?: any) => ${target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.Element`
+        : `globalThis.JSX.Element`} & {
 		__ctx?: {
 			attrs?: any;
 			slots?: T extends { $slots: infer Slots } ? Slots : Record<string, any>;

package/lib/codegen/script/index.js

@@ -115,19 +115,26 @@ function* generateExportDefault(options) {
         yield* (0, src_1.generateSrc)(options.sfc.script.src);
         return;
     }
-    let prefix;
-    let suffix;
+    const expression = `{} as typeof __VLS_export`;
     if (options.sfc.script && options.scriptRanges?.exportDefault) {
         const { exportDefault, componentOptions } = options.scriptRanges;
-        prefix = (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.start, (componentOptions ?? exportDefault).expression.start, codeFeatures_1.codeFeatures.all);
-        suffix = (0, utils_1.generateSfcBlockSection)(options.sfc.script, (componentOptions ?? exportDefault).expression.end, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.start, (componentOptions ?? exportDefault).expression.start, codeFeatures_1.codeFeatures.all);
+        yield expression;
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, (componentOptions ?? exportDefault).expression.end, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
     }
     else {
-        prefix = `export default `;
-        suffix = utils_1.endOfLine;
+        yield `export `;
+        if (options.sfc.template) {
+            for (let i = 0; i < 'template'.length + 1; i++) {
+                yield [
+                    ``,
+                    'main',
+                    options.sfc.template.start + 1 + i,
+                    i ? { __combineOffset: i } : codeFeatures_1.codeFeatures.navigationWithoutRename,
+                ];
+            }
+        }
+        yield `default ${expression}${utils_1.endOfLine}`;
     }
-    yield prefix;
-    yield `{} as typeof __VLS_export`;
-    yield suffix;
 }
 //# sourceMappingURL=index.js.map

package/lib/codegen/script/template.js

@@ -15,7 +15,6 @@ function* generateTemplate(options, ctx) {
     ctx.generatedTemplate = true;
     yield* generateSelf(options);
     yield* generateTemplateCtx(options, ctx);
-    yield* generateTemplateElements();
     yield* generateTemplateComponents(options);
     yield* generateTemplateDirectives(options);
     yield* generateTemplateBody(options, ctx);
@@ -93,9 +92,6 @@ function* generateTemplateCtx(options, ctx) {
     yield* (0, merge_1.generateSpreadMerge)(exps);
     yield utils_1.endOfLine;
 }
-function* generateTemplateElements() {
-    yield `let __VLS_elements!: __VLS_IntrinsicElements${utils_1.endOfLine}`;
-}
 function* generateTemplateComponents(options) {
     const types = [`typeof __VLS_ctx`];
     if (options.sfc.script && options.scriptRanges?.componentOptions?.components) {

package/lib/codegen/template/context.js

@@ -125,8 +125,12 @@ function createTemplateCodegenContext(options, templateAst) {
                 return {
                     ...features,
                     verification: {
-                        shouldReport: () => {
-                            data.expectError.token++;
+                        shouldReport: (source, code) => {
+                            if (typeof features.verification !== 'object'
+                                || !features.verification.shouldReport
+                                || features.verification.shouldReport(source, code) === true) {
+                                data.expectError.token++;
+                            }
                             return false;
                         },
                     },

package/lib/codegen/template/element.js

@@ -182,10 +182,10 @@ function* generateComponent(options, ctx, node) {
 function* generateElement(options, ctx, node) {
     const [startTagOffset, endTagOffset] = (0, shared_2.getElementTagOffsets)(node, options.template);
     const failedPropExps = [];
-    yield `__VLS_asFunctionalElement(__VLS_elements`;
+    yield `__VLS_asFunctionalElement(__VLS_intrinsics`;
     yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     if (endTagOffset !== undefined) {
-        yield `, __VLS_elements`;
+        yield `, __VLS_intrinsics`;
         yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     }
     yield `)(`;
@@ -195,17 +195,17 @@ function* generateElement(options, ctx, node) {
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
     const reference = yield* generateElementReference(options, ctx, node);
     if (reference) {
-        let typeExp = `__VLS_NativeElements['${node.tag}']`;
+        let typeExp = `__VLS_Elements['${node.tag}']`;
         if (ctx.inVFor) {
             typeExp += `[]`;
         }
         ctx.addTemplateRef(reference.name, typeExp, reference.offset);
     }
     if (ctx.singleRootNodes.has(node)) {
-        ctx.singleRootElTypes.push(`__VLS_NativeElements['${node.tag}']`);
+        ctx.singleRootElTypes.push(`__VLS_Elements['${node.tag}']`);
     }
     if (hasVBindAttrs(options, ctx, node)) {
-        ctx.inheritedAttrVars.add(`__VLS_elements.${node.tag}`);
+        ctx.inheritedAttrVars.add(`__VLS_intrinsics.${node.tag}`);
     }
     (0, styleScopedClasses_1.collectStyleScopedClassReferences)(options, ctx, node);
     const { currentComponent } = ctx;

package/lib/codegen/template/index.d.ts

@@ -1,4 +1,3 @@
-import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
 export interface TemplateCodegenOptions {
@@ -23,7 +22,7 @@ declare function generate(options: TemplateCodegenOptions): {
         ignoreError?: boolean;
         expectError?: {
             token: number;
-            node: CompilerDOM.CommentNode;
+            node: import("@vue/compiler-dom").CommentNode;
         };
         generic?: {
             content: string;
@@ -54,7 +53,7 @@ declare function generate(options: TemplateCodegenOptions): {
     }[];
     emptyClassOffsets: number[];
     inlayHints: import("../inlayHints").InlayHintInfo[];
-    bindingAttrLocs: CompilerDOM.SourceLocation[];
+    bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
     inheritedAttrVars: Set<string>;
     templateRefs: Map<string, {
         typeExp: string;
@@ -65,7 +64,7 @@ declare function generate(options: TemplateCodegenOptions): {
         used: boolean;
     } | undefined;
     singleRootElTypes: string[];
-    singleRootNodes: Set<CompilerDOM.ElementNode | null>;
+    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     addTemplateRef(name: string, typeExp: string, offset: number): void;
     accessExternalVariable(name: string, offset?: number): void;
     hasLocalVariable(name: string): boolean;
@@ -76,7 +75,6 @@ declare function generate(options: TemplateCodegenOptions): {
     generateHoistVariables(): Generator<string, void, unknown>;
     generateConditionGuards(): Generator<string, void, unknown>;
     generateAutoImportCompletion(): Generator<Code>;
-    enter(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): boolean;
+    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
     exit(): Generator<Code>;
 };
-export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;

package/lib/codegen/template/index.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generate;
-exports.forEachElementNode = forEachElementNode;
-const CompilerDOM = require("@vue/compiler-dom");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -140,37 +138,4 @@ function* generateRootEl(ctx) {
     yield utils_1.endOfLine;
     return `__VLS_RootEl`;
 }
-function* forEachElementNode(node) {
-    if (node.type === CompilerDOM.NodeTypes.ROOT) {
-        for (const child of node.children) {
-            yield* forEachElementNode(child);
-        }
-    }
-    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
-        const patchForNode = (0, templateChild_1.getVForNode)(node);
-        if (patchForNode) {
-            yield* forEachElementNode(patchForNode);
-        }
-        else {
-            yield node;
-            for (const child of node.children) {
-                yield* forEachElementNode(child);
-            }
-        }
-    }
-    else if (node.type === CompilerDOM.NodeTypes.IF) {
-        // v-if / v-else-if / v-else
-        for (const branch of node.branches) {
-            for (const childNode of branch.children) {
-                yield* forEachElementNode(childNode);
-            }
-        }
-    }
-    else if (node.type === CompilerDOM.NodeTypes.FOR) {
-        // v-for
-        for (const child of node.children) {
-            yield* forEachElementNode(child);
-        }
-    }
-}
 //# sourceMappingURL=index.js.map

package/lib/codegen/template/templateChild.js

@@ -167,22 +167,15 @@ function getVIfNode(node) {
     }
 }
 function parseInterpolationNode(node, template) {
-    let content = node.content.loc.source;
     let start = node.content.loc.start.offset;
-    let leftCharacter;
-    let rightCharacter;
+    let end = node.content.loc.end.offset;
     // fix https://github.com/vuejs/language-tools/issues/1787
-    while ((leftCharacter = template.slice(start - 1, start)).trim() === '' && leftCharacter.length) {
+    while (template[start - 1]?.trim() === '') {
         start--;
-        content = leftCharacter + content;
     }
-    while ((rightCharacter = template.slice(start + content.length, start + content.length + 1)).trim() === ''
-        && rightCharacter.length) {
-        content = content + rightCharacter;
+    while (template[end]?.trim() === '') {
+        end++;
     }
-    return [
-        content,
-        start,
-    ];
+    return [template.slice(start, end), start];
 }
 //# sourceMappingURL=templateChild.js.map

package/lib/codegen/template/vIf.js

@@ -9,6 +9,10 @@ const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
 function* generateVIf(options, ctx, node) {
     const originalBlockConditionsLength = ctx.blockConditions.length;
+    const isFragment = node.codegenNode
+        && 'consequent' in node.codegenNode
+        && 'tag' in node.codegenNode.consequent
+        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
         if (i === 0) {
@@ -29,7 +33,7 @@ function* generateVIf(options, ctx, node) {
             yield ` `;
         }
         yield `{${utils_1.newLine}`;
-        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, branch.children, isFragment(node));
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, branch.children, i !== 0 || isFragment);
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
             ctx.blockConditions[ctx.blockConditions.length - 1] = `!${ctx.blockConditions[ctx.blockConditions.length - 1]}`;
@@ -37,10 +41,4 @@ function* generateVIf(options, ctx, node) {
     }
     ctx.blockConditions.length = originalBlockConditionsLength;
 }
-function isFragment(node) {
-    return node.codegenNode
-        && 'consequent' in node.codegenNode
-        && 'tag' in node.codegenNode.consequent
-        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
-}
 //# sourceMappingURL=vIf.js.map

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const CompilerDOM = require("@vue/compiler-dom");
-const template_1 = require("../codegen/template");
+const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
 const shared_1 = require("./shared");
 const codeFeatures = {
     ...shared_1.allCodeFeatures,
@@ -28,7 +28,7 @@ const plugin = () => {
 };
 exports.default = plugin;
 function* generate(templateAst) {
-    for (const node of (0, template_1.forEachElementNode)(templateAst)) {
+    for (const node of (0, forEachTemplateNode_1.forEachElementNode)(templateAst)) {
         for (const prop of node.props) {
             if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
                 && prop.name === 'bind'

package/lib/utils/forEachTemplateNode.d.ts

@@ -0,0 +1,3 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;
+export declare function forEachInterpolationNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): Generator<CompilerDOM.InterpolationNode>;

package/lib/utils/forEachTemplateNode.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachElementNode = forEachElementNode;
+exports.forEachInterpolationNode = forEachInterpolationNode;
+const CompilerDOM = require("@vue/compiler-dom");
+function* forEachElementNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        yield node;
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const childNode of branch.children) {
+                yield* forEachElementNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+}
+function* forEachInterpolationNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+        yield* forEachInterpolationNode(node.content);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
+        for (const child of node.children) {
+            if (typeof child === 'object') {
+                yield* forEachInterpolationNode(child);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+        yield node;
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const childNode of branch.children) {
+                yield* forEachInterpolationNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        for (const child of node.children) {
+            yield* forEachInterpolationNode(child);
+        }
+    }
+}
+//# sourceMappingURL=forEachTemplateNode.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.1.2",
+	"version": "3.1.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "77db3d889305e8c02740f4c14793bff0156ccdb8"
+	"gitHead": "9670176c727993d16f9224f48406077e20972353"
 }