@vue/language-core - npm Package Compare versions

Comparing version 3.2.8 to 3.2.9

lib/template/compile.d.ts

+import { type CompilerOptions } from '@vue/compiler-dom';
+export declare function compileTemplate(source: string, options: CompilerOptions): import("@vue/compiler-dom").RootNode;

lib/template/compile.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplate = compileTemplate;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const transformElement_1 = require("./transforms/transformElement");
+const transformText_1 = require("./transforms/transformText");
+const vFor_1 = require("./transforms/vFor");
+const vIf_1 = require("./transforms/vIf");
+function compileTemplate(source, options) {
+    const [nodeTransforms, directiveTransforms] = (0, compiler_dom_1.getBaseTransformPreset)();
+    const resolvedOptions = {
+        ...options,
+        comments: true,
+        nodeTransforms: [
+            nodeTransforms[0], // transformVBindShorthand
+            vIf_1.transformIf,
+            vFor_1.transformFor,
+            transformElement_1.transformElement,
+            transformText_1.transformText,
+            ...options.nodeTransforms || [],
+        ],
+        directiveTransforms: {
+            ...directiveTransforms,
+            ...options.directiveTransforms,
+        },
+    };
+    const ast = (0, compiler_dom_1.parse)(source, resolvedOptions);
+    (0, compiler_dom_1.transform)(ast, resolvedOptions);
+    return ast;
+}
+//# sourceMappingURL=compile.js.map

lib/template/transforms/transformElement.d.ts

+import { type NodeTransform } from '@vue/compiler-dom';
+export declare const transformElement: NodeTransform;

lib/template/transforms/transformElement.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformElement = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const transformElement = (node, context) => {
+    return () => {
+        if (node.type !== compiler_dom_1.NodeTypes.ELEMENT || node.tagType === compiler_dom_1.ElementTypes.TEMPLATE) {
+            return;
+        }
+        const isComponent = node.tagType === compiler_dom_1.ElementTypes.COMPONENT;
+        const isSlotOutlet = node.tagType === compiler_dom_1.ElementTypes.SLOT;
+        for (const prop of node.props) {
+            if (prop.type !== compiler_dom_1.NodeTypes.DIRECTIVE) {
+                continue;
+            }
+            if (prop.name === 'slot') {
+                if (!isComponent) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_MISPLACED, prop.loc));
+                }
+                continue;
+            }
+            const isVBind = prop.name === 'bind';
+            const isVOn = prop.name === 'on';
+            if (!prop.arg && (isVBind || isVOn)) {
+                if (!prop.exp) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(isVBind
+                        ? compiler_dom_1.ErrorCodes.X_V_BIND_NO_EXPRESSION
+                        : compiler_dom_1.ErrorCodes.X_V_ON_NO_EXPRESSION, prop.loc));
+                }
+                continue;
+            }
+            const runtimeDirectives = [];
+            const directiveTransform = context.directiveTransforms[prop.name];
+            if (directiveTransform) {
+                const { needRuntime } = directiveTransform(prop, node, context);
+                if (needRuntime) {
+                    runtimeDirectives.push(prop);
+                }
+            }
+            else if (!(0, shared_1.isBuiltInDirective)(prop.name)) {
+                runtimeDirectives.push(prop);
+            }
+            if (isSlotOutlet && runtimeDirectives.length) {
+                context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET, prop.loc));
+            }
+        }
+        if (isComponent) {
+            let hasTemplateSlots = false;
+            let hasNamedDefaultSlot = false;
+            const implicitDefaultChildren = [];
+            const seenSlotNames = new Set();
+            const onComponentSlot = (0, compiler_dom_1.findDir)(node, 'slot', true);
+            for (const child of node.children) {
+                let slotDir;
+                if (!(0, compiler_dom_1.isTemplateNode)(child) || !(slotDir = (0, compiler_dom_1.findDir)(child, 'slot', true))) {
+                    if (child.type !== compiler_dom_1.NodeTypes.COMMENT) {
+                        implicitDefaultChildren.push(child);
+                    }
+                    continue;
+                }
+                if (onComponentSlot) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE, slotDir.loc));
+                    break;
+                }
+                if ((0, compiler_dom_1.findDir)(child, /^(?:if|else-if|else|for)$/, true)) {
+                    continue;
+                }
+                hasTemplateSlots = true;
+                const staticSlotName = slotDir.arg
+                    ? (0, compiler_dom_1.isStaticExp)(slotDir.arg)
+                        ? slotDir.arg.content
+                        : undefined
+                    : 'default';
+                if (staticSlotName) {
+                    if (seenSlotNames.has(staticSlotName)) {
+                        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES, slotDir.loc));
+                        continue;
+                    }
+                    seenSlotNames.add(staticSlotName);
+                    if (staticSlotName === 'default') {
+                        hasNamedDefaultSlot = true;
+                    }
+                }
+            }
+            if (hasTemplateSlots && hasNamedDefaultSlot
+                && implicitDefaultChildren.some(node => node.type !== compiler_dom_1.NodeTypes.TEXT || !!node.content.trim())) {
+                context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN, implicitDefaultChildren[0].loc));
+            }
+            context.components.add(node.tag);
+        }
+    };
+};
+exports.transformElement = transformElement;
+//# sourceMappingURL=transformElement.js.map

lib/template/transforms/transformText.d.ts

+import { type NodeTransform } from '@vue/compiler-dom';
+export declare const transformText: NodeTransform;

lib/template/transforms/transformText.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformText = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const transformText = node => {
+    if (node.type === compiler_dom_1.NodeTypes.ROOT
+        || node.type === compiler_dom_1.NodeTypes.ELEMENT
+        || node.type === compiler_dom_1.NodeTypes.FOR
+        || node.type === compiler_dom_1.NodeTypes.IF_BRANCH) {
+        return () => {
+            const children = node.children;
+            let currentContainer = undefined;
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                if ((0, compiler_dom_1.isText)(child)) {
+                    for (let j = i + 1; j < children.length; j++) {
+                        const next = children[j];
+                        if ((0, compiler_dom_1.isText)(next)) {
+                            currentContainer ??= children[i] = (0, compiler_dom_1.createCompoundExpression)([child], child.loc);
+                            currentContainer.children.push(` + `, next);
+                            children.splice(j, 1);
+                            j--;
+                        }
+                        else {
+                            currentContainer = undefined;
+                            break;
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+exports.transformText = transformText;
+//# sourceMappingURL=transformText.js.map

lib/template/transforms/vFor.d.ts

+export declare const transformFor: import("@vue/compiler-dom").NodeTransform;

lib/template/transforms/vFor.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFor = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+exports.transformFor = (0, utils_1.createStructuralDirectiveTransform)('for', (node, dir, context) => {
+    if (!dir.exp) {
+        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_FOR_NO_EXPRESSION, dir.loc));
+        return;
+    }
+    const parseResult = dir.forParseResult;
+    if (!parseResult) {
+        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION, dir.loc));
+        return;
+    }
+    const { source, value, key, index } = parseResult;
+    const forNode = {
+        type: compiler_dom_1.NodeTypes.FOR,
+        loc: dir.loc,
+        source,
+        valueAlias: value,
+        keyAlias: key,
+        objectIndexAlias: index,
+        parseResult,
+        children: [node],
+    };
+    context.replaceNode(forNode);
+    return () => {
+        if ((0, compiler_dom_1.isTemplateNode)(node)) {
+            for (const child of node.children) {
+                if (child.type === compiler_dom_1.NodeTypes.ELEMENT) {
+                    const key = (0, compiler_dom_1.findProp)(child, 'key');
+                    if (key) {
+                        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT, key.loc));
+                        break;
+                    }
+                }
+            }
+        }
+    };
+});
+//# sourceMappingURL=vFor.js.map

lib/template/transforms/vIf.d.ts

+export declare const transformIf: import("@vue/compiler-dom").NodeTransform;

lib/template/transforms/vIf.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformIf = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+exports.transformIf = (0, utils_1.createStructuralDirectiveTransform)(/^(?:if|else-if|else)$/, (node, dir, context) => {
+    if (dir.name !== 'else'
+        && (!dir.exp || !dir.exp.content.trim())) {
+        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_IF_NO_EXPRESSION, dir.loc));
+    }
+    if (dir.name === 'if') {
+        const branch = createIfBranch(node, dir);
+        const ifNode = {
+            type: compiler_dom_1.NodeTypes.IF,
+            loc: (0, utils_1.cloneLoc)(node.loc),
+            branches: [branch],
+        };
+        context.replaceNode(ifNode);
+    }
+    else {
+        const siblings = context.parent.children;
+        const comments = [];
+        let i = siblings.indexOf(node);
+        while (i-- >= -1) {
+            const sibling = siblings[i];
+            if (sibling?.type === compiler_dom_1.NodeTypes.COMMENT) {
+                context.removeNode(sibling);
+                comments.unshift(sibling);
+                continue;
+            }
+            if (sibling?.type === compiler_dom_1.NodeTypes.TEXT && !sibling.content.trim().length) {
+                context.removeNode(sibling);
+                continue;
+            }
+            if (sibling?.type === compiler_dom_1.NodeTypes.IF) {
+                if (!sibling.branches.at(-1).condition) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, node.loc));
+                }
+                context.removeNode();
+                const branch = createIfBranch(node, dir);
+                if (comments.length) {
+                    branch.children.unshift(...comments);
+                }
+                if (branch.userKey) {
+                    for (const { userKey } of sibling.branches) {
+                        if (isSameKey(userKey, branch.userKey)) {
+                            context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_IF_SAME_KEY, branch.userKey.loc));
+                        }
+                    }
+                }
+                sibling.branches.push(branch);
+                (0, compiler_dom_1.traverseNode)(branch, context);
+                context.currentNode = null;
+            }
+            else {
+                context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, node.loc));
+            }
+            break;
+        }
+    }
+});
+function createIfBranch(node, dir) {
+    return {
+        type: compiler_dom_1.NodeTypes.IF_BRANCH,
+        loc: node.loc,
+        condition: dir.name === 'else' ? undefined : dir.exp,
+        children: [node],
+        userKey: (0, compiler_dom_1.findProp)(node, 'key'),
+    };
+}
+function isSameKey(a, b) {
+    if (!a || a.type !== b.type) {
+        return false;
+    }
+    if (a.type === compiler_dom_1.NodeTypes.ATTRIBUTE) {
+        if (a.value.content !== b.value.content) {
+            return false;
+        }
+    }
+    else {
+        const exp = a.exp;
+        const branchExp = b.exp;
+        if (exp.type !== branchExp.type
+            || exp.type !== compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION
+            || exp.isStatic !== branchExp.isStatic
+            || exp.content !== branchExp.content) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=vIf.js.map

lib/template/utils.d.ts

+import { type NodeTransform, type SourceLocation, type StructuralDirectiveTransform } from '@vue/compiler-dom';
+export declare function createStructuralDirectiveTransform(name: string | RegExp, fn: StructuralDirectiveTransform): NodeTransform;
+export declare function cloneLoc(loc: SourceLocation): SourceLocation;

lib/template/utils.js

+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
+exports.cloneLoc = cloneLoc;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+function createStructuralDirectiveTransform(name, fn) {
+    const matches = (0, shared_1.isString)(name)
+        ? (n) => n === name
+        : (n) => name.test(n);
+    return (node, context) => {
+        if (node.type === compiler_dom_1.NodeTypes.ELEMENT) {
+            const { props } = node;
+            const exitFns = [];
+            for (let i = 0; i < props.length; i++) {
+                const prop = props[i];
+                if (prop.type === compiler_dom_1.NodeTypes.DIRECTIVE && matches(prop.name)) {
+                    props.splice(i, 1);
+                    i--;
+                    const onExit = fn(node, prop, context);
+                    if (onExit) {
+                        exitFns.push(onExit);
+                    }
+                }
+            }
+            return exitFns;
+        }
+    };
+}
+function cloneLoc(loc) {
+    return {
+        start: { ...loc.start },
+        end: { ...loc.end },
+        source: loc.source,
+    };
+}
+//# sourceMappingURL=utils.js.map

index.d.ts

@@ -7,2 +7,3 @@ export * from './lib/codegen/template';
 export * from './lib/plugins';
+export * from './lib/template/compile';
 export * from './lib/types';
@@ -9,0 +10,0 @@ export * from './lib/utils/collectBindings';

index.js

@@ -24,2 +24,3 @@ "use strict";
 __exportStar(require("./lib/plugins"), exports);
+__exportStar(require("./lib/template/compile"), exports);
 __exportStar(require("./lib/types"), exports);
@@ -26,0 +27,0 @@ __exportStar(require("./lib/utils/collectBindings"), exports);

lib/codegen/template/element.d.ts

@@ -7,1 +7,2 @@ import * as CompilerDOM from '@vue/compiler-dom';
 export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
+export declare function generateFragment(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;

lib/codegen/template/element.js

@@ -38,2 +38,3 @@ "use strict";
 exports.generateElement = generateElement;
+exports.generateFragment = generateFragment;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
@@ -272,2 +273,18 @@ const shared_1 = require("@vue/shared");
 }
+function* generateFragment(options, ctx, node) {
+    const [startTagOffset] = (0, shared_2.getElementTagOffsets)(node, options.template);
+    // special case for <template v-for="..." :key="..." />
+    if (node.props.length) {
+        yield `__VLS_asFunctionalElement(__VLS_intrinsics.template)(`;
+        const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+        yield `{${utils_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.checkUnknownProps);
+        yield `}`;
+        yield (0, boundary_1.endBoundary)(token, startTagOffset + node.tag.length);
+        yield `)${utils_1.endOfLine}`;
+    }
+    for (const child of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
+    }
+}
 function* generateStyleScopedClassReferences({ template, typescript: ts }, node) {
@@ -274,0 +291,0 @@ for (const prop of node.props) {

lib/codegen/template/elementProps.js

@@ -112,3 +112,3 @@ "use strict";
             const shouldSpread = propName === 'style' || propName === 'class';
-            const shouldCamelize = isComponent && getShouldCamelize(options, prop, propName);
+            const shouldCamelize = getShouldCamelize(options, node, prop, propName);
             const features = getPropsCodeFeatures(strictPropsCheck);
@@ -152,3 +152,3 @@ if (shouldSpread) {
             const shouldSpread = prop.name === 'style' || prop.name === 'class';
-            const shouldCamelize = isComponent && getShouldCamelize(options, prop, prop.name);
+            const shouldCamelize = getShouldCamelize(options, node, prop, prop.name);
             const features = getPropsCodeFeatures(strictPropsCheck);
@@ -239,6 +239,6 @@ if (shouldSpread) {
 }
-function getShouldCamelize(options, prop, propName) {
-    return (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
-        || !prop.arg
-        || (prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))
+function getShouldCamelize(options, node, prop, propName) {
+    return (node.tagType === CompilerDOM.ElementTypes.COMPONENT
+        || node.tagType === CompilerDOM.ElementTypes.SLOT) && (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
+        || prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic)
         && (0, shared_2.hyphenateAttr)(propName) === propName
@@ -245,0 +245,0 @@ && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, picomatch_1.isMatch)(propName, pattern));

lib/codegen/template/templateChild.d.ts

@@ -5,3 +5,3 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, enterNode?: boolean): Generator<Code>;
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, enterNode?: boolean, isVForChild?: boolean): Generator<Code>;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

lib/codegen/template/templateChild.js

@@ -48,10 +48,6 @@ "use strict";
 const vSlot_1 = require("./vSlot");
-function* generateTemplateChild(options, ctx, node, enterNode = true) {
+function* generateTemplateChild(options, ctx, node, enterNode = true, isVForChild = false) {
     if (enterNode && !ctx.enter(node)) {
         return;
     }
-    const cur = node;
-    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
-        cur.codegenNode = cur.codegenNode.value;
-    }
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
@@ -66,23 +62,21 @@ for (const item of collectSingleRootNodes(options, node.children)) {
     else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
-        let slotDir;
         if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
             yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
         }
-        else if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE
-            && ctx.components.length
-            && (slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot'))) {
-            yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, ctx.components[ctx.components.length - 1]());
-        }
-        else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
-            || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-            yield* (0, element_1.generateElement)(options, ctx, node);
-        }
         else {
-            yield* (0, element_1.generateComponent)(options, ctx, node);
+            const slotDir = node.props.find(CompilerDOM.isVSlot);
+            if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE && ctx.components.length && slotDir) {
+                yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, ctx.components.at(-1)());
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE && isVForChild) {
+                yield* (0, element_1.generateFragment)(options, ctx, node);
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.COMPONENT) {
+                yield* (0, element_1.generateComponent)(options, ctx, node);
+            }
+            else {
+                yield* (0, element_1.generateElement)(options, ctx, node);
+            }
         }
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-        // {{ var }}
-        yield* generateTemplateChild(options, ctx, node.content, false);
-    }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
@@ -110,5 +104,2 @@ // {{ ... }} {{ ... }}
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT) {
-        // not needed progress
-    }
     if (enterNode) {
@@ -115,0 +106,0 @@ yield* ctx.exit();

lib/codegen/template/vFor.js

@@ -70,24 +70,6 @@ "use strict";
     yield `) {${utils_1.newLine}`;
-    let isFragment = true;
-    for (const argument of node.codegenNode?.children.arguments ?? []) {
-        if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
-            && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
-            && argument.returns.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
-            if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
-                isFragment = false;
-                continue;
-            }
-            for (const prop of argument.returns.props.properties) {
-                if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                    && !prop.value.isStatic) {
-                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, `(`, `)`);
-                    yield utils_1.endOfLine;
-                }
-            }
-        }
-    }
     const { inVFor } = ctx;
     ctx.inVFor = true;
     for (const child of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, isFragment);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, false, true);
     }
@@ -94,0 +76,0 @@ ctx.inVFor = inVFor;

lib/codegen/template/vIf.js

@@ -45,6 +45,2 @@ "use strict";
     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++) {
@@ -71,3 +67,3 @@ const branch = node.branches[i];
         for (const child of branch.children) {
-            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, i !== 0 || isFragment);
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, i !== 0, true);
         }
@@ -74,0 +70,0 @@ yield `}${utils_1.newLine}`;

lib/languagePlugin.js

@@ -41,2 +41,3 @@ "use strict";
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const LanguageCore = __importStar(require("../index"));
 const plugins_1 = require("./plugins");
@@ -64,2 +65,3 @@ const virtualCode_1 = require("./virtualCode");
             '@vue/compiler-dom': CompilerDOM,
+            '@vue/language-core': LanguageCore,
             typescript: ts,
@@ -66,0 +68,0 @@ },

lib/plugins/file-md.js

@@ -8,10 +8,9 @@ "use strict";
 const frontmatterReg = /^---[\s\S]*?\n---(?:\r?\n|$)/;
-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 codeblockReg = /(`{3}|\${2})[\s\S]+?\1/g;
 const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
-const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
-const angleBracketReg = /<\S*:\S*>/g;
-const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
+const sfcBlockReg = /<(script|style)\b[^>]*>([\s\S]*?)<\/\1>/g;
+const htmlTagReg = /(?<=<\/?)([a-z][a-z0-9-]*)\b[^>]*(?=>)/gi;
+const interpolationReg = /(?<=\{\{)[\s\S]*?(?=\}\})/g;
+const inlineCodeReg = /(`{1,2})[^`]+\1/g;
+const angleBracketReg = /<[^\s:]*:\S*>/g;
 const plugin = ({ vueCompilerOptions }) => {
@@ -32,28 +31,25 @@ return {
             }
-            content = content
-                // frontmatter
-                .replace(frontmatterReg, match => ' '.repeat(match.length))
-                // code block
-                .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
-                // 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
-                .replace(codeSnippetImportReg, match => ' '.repeat(match.length));
+            for (const reg of [frontmatterReg, codeblockReg, codeSnippetImportReg]) {
+                content = content.replace(reg, match => ' '.repeat(match.length));
+            }
             const codes = [];
-            for (const match of content.matchAll(sfcBlockReg)) {
-                const matchText = match[0];
-                codes.push([matchText, undefined, match.index]);
+            for (const { 0: text, index } of content.matchAll(sfcBlockReg)) {
+                codes.push([text, undefined, index]);
                 codes.push('\n\n');
-                content = content.slice(0, match.index) + ' '.repeat(matchText.length)
-                    + content.slice(match.index + matchText.length);
+                content = content.slice(0, index) + ' '.repeat(text.length) + content.slice(index + text.length);
             }
-            content = content
-                // inline code block
-                .replace(inlineCodeblockReg, match => `\`${' '.repeat(match.length - 2)}\``)
-                // angle bracket: <http://foo.com>
-                .replace(angleBracketReg, match => ' '.repeat(match.length))
-                // [foo](http://foo.com)
-                .replace(linkReg, match => ' '.repeat(match.length));
+            const ranges = [];
+            for (const reg of [htmlTagReg, interpolationReg]) {
+                for (const { 0: text, index } of content.matchAll(reg)) {
+                    ranges.push([index, index + text.length]);
+                }
+            }
+            for (const reg of [inlineCodeReg, angleBracketReg]) {
+                for (const { 0: text, index } of content.matchAll(reg)) {
+                    if (ranges.some(([start, end]) => index >= start && index < end)) {
+                        continue;
+                    }
+                    content = content.slice(0, index) + ' '.repeat(text.length) + content.slice(index + text.length);
+                }
+            }
             codes.push('<template>\n');
@@ -60,0 +56,0 @@ codes.push([content, undefined, 0]);

lib/plugins/vue-template-html.js

 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const compile_1 = require("../template/compile");
 const shouldAddSuffix = /(?<=<[^>/]+)$/;
-const plugin = ({ modules }) => {
-    const CompilerDOM = modules['@vue/compiler-dom'];
+const plugin = () => {
     return {
@@ -16,7 +50,3 @@ version: 2.2,
                 }
-                const ast = CompilerDOM.parse(template, {
-                    ...options,
-                    comments: true,
-                });
-                CompilerDOM.transform(ast, options);
+                const ast = (0, compile_1.compileTemplate)(template, options);
                 return {
@@ -101,7 +131,2 @@ ast,
                     }
-                    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-                        if (!tryUpdateNode(node.content)) {
-                            return false;
-                        }
-                    }
                     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
@@ -108,0 +133,0 @@ for (const childNode of node.children) {

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

@@ -181,6 +181,2 @@ "use strict";
             }
-            else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-                // {{ var }}
-                visit(node.content);
-            }
             else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
@@ -187,0 +183,0 @@ // {{ ... }} {{ ... }}

lib/types.d.ts

@@ -104,2 +104,3 @@ import type { CodeInformation } from '@volar/language-core';
         '@vue/compiler-dom': typeof CompilerDOM;
+        '@vue/language-core': typeof import('../index');
     };
@@ -106,0 +107,0 @@ compilerOptions: ts.CompilerOptions;

lib/utils/forEachTemplateNode.js

@@ -75,5 +75,2 @@ "use strict";
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-        yield* forEachInterpolationNode(node.content);
-    }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
@@ -80,0 +77,0 @@ for (const child of node.children) {

lib/virtualCode/ir.js

 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useIR = useIR;
-const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const alien_signals_1 = require("alien-signals");
 const signals_1 = require("../utils/signals");
-const normalize_1 = require("./normalize");
 function useIR(ts, plugins, fileName, getSnapshot, getParseSfcResult) {
@@ -232,3 +197,2 @@ const getUntrackedSnapshot = () => {
             const warnings = [];
-            const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset();
             let options = {
@@ -238,4 +202,2 @@ onError: err => errors.push(err),
                 expressionPlugins: ['typescript'],
-                nodeTransforms,
-                directiveTransforms,
             };
@@ -251,3 +213,2 @@ for (const plugin of plugins) {
                     if (result) {
-                        (0, normalize_1.normalizeTemplateAST)(result.ast);
                         return {
@@ -254,0 +215,0 @@ snapshot: getUntrackedSnapshot(),

package.json

 {
 	"name": "@vue/language-core",
-	"version": "3.2.8",
+	"version": "3.2.9",
 	"license": "MIT",
 	"files": [
-		"**/*.js",
-		"**/*.d.ts"
+		"index.d.ts",
+		"index.js",
+		"lib/**/*.d.ts",
+		"lib/**/*.js",
+		"types"
 	],
@@ -22,3 +25,3 @@ "sideEffects": false,
 		"@vue/shared": "^3.5.0",
-		"alien-signals": "^3.1.2",
+		"alien-signals": "^3.2.0",
 		"muggle-string": "^0.4.1",
@@ -29,3 +32,3 @@ "path-browserify": "^1.0.1",
 	"devDependencies": {
-		"@types/node": "^22.10.4",
+		"@types/node": "^24.1.0",
 		"@types/path-browserify": "^1.0.3",
@@ -36,3 +39,3 @@ "@types/picomatch": "^4.0.3",
 	},
-	"gitHead": "618bd6bfb19729726787df7b52fccda72c888c95"
+	"gitHead": "9c1fd47ffe25e86394232dfc76453a5f76cb4fe0"
 }

lib/virtualCode/normalize.d.ts

-import * as CompilerDOM from '@vue/compiler-dom';
-export declare function normalizeTemplateAST(root: CompilerDOM.RootNode): void;

lib/virtualCode/normalize.js

-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeTemplateAST = normalizeTemplateAST;
-const CompilerDOM = __importStar(require("@vue/compiler-dom"));
-const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
-// See https://github.com/vuejs/core/issues/3498
-function normalizeTemplateAST(root) {
-    // @ts-ignore
-    const transformContext = {
-        onError: () => { },
-        helperString: str => str.toString(),
-        replaceNode: () => { },
-        cacheHandlers: false,
-        prefixIdentifiers: false,
-        scopes: {
-            vFor: 0,
-            vOnce: 0,
-            vPre: 0,
-            vSlot: 0,
-        },
-        expressionPlugins: ['typescript'],
-    };
-    for (const { children, codegenNode, props } of (0, forEachTemplateNode_1.forEachElementNode)(root)) {
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-            if (child.type !== CompilerDOM.NodeTypes.ELEMENT) {
-                continue;
-            }
-            const forNode = getVForNode(child, transformContext);
-            if (forNode) {
-                children[i] = forNode;
-                continue;
-            }
-            const ifNode = getVIfNode(child, transformContext);
-            if (ifNode) {
-                const normalized = normalizeIfBranch(ifNode, children, i);
-                children.splice(i, normalized.end - i + 1, normalized.node);
-                continue;
-            }
-        }
-        // #4539
-        if (codegenNode
-            && 'props' in codegenNode
-            && codegenNode.props
-            && 'properties' in codegenNode.props) {
-            for (const p of codegenNode.props.properties) {
-                if (p.key.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                    && p.key.content === 'key'
-                    && !p.key.isHandlerKey
-                    && !p.key.loc.source
-                    && p.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                    && p.value.constType === CompilerDOM.ConstantTypes.NOT_CONSTANT) {
-                    const contentBeforeValue = root.loc.source.slice(0, p.value.loc.start.offset);
-                    const argOffset = contentBeforeValue.lastIndexOf('key');
-                    props.push({
-                        type: CompilerDOM.NodeTypes.DIRECTIVE,
-                        name: 'bind',
-                        exp: p.value,
-                        loc: p.loc,
-                        arg: {
-                            ...p.key,
-                            loc: {
-                                start: { line: -1, column: -1, offset: argOffset },
-                                end: { line: -1, column: -1, offset: argOffset + 'key'.length },
-                                source: 'key',
-                            },
-                        },
-                        modifiers: [],
-                    });
-                    break;
-                }
-            }
-        }
-    }
-}
-function normalizeIfBranch(ifNode, children, start) {
-    let end = start;
-    let comments = [];
-    for (let i = start + 1; i < children.length; i++) {
-        const sibling = children[i];
-        if (sibling.type === CompilerDOM.NodeTypes.COMMENT) {
-            comments.push(sibling);
-            continue;
-        }
-        if (sibling.type === CompilerDOM.NodeTypes.TEXT && !sibling.content.trim()) {
-            continue;
-        }
-        const elseBranch = getVElseDirective(sibling);
-        if (elseBranch) {
-            const branchNode = {
-                ...elseBranch.element,
-                props: elseBranch.element.props.filter(prop => prop !== elseBranch.directive),
-            };
-            const branch = createIfBranch(branchNode, elseBranch.directive);
-            if (comments.length) {
-                branch.children = [...comments, ...branch.children];
-            }
-            ifNode.branches.push(branch);
-            comments = [];
-            end = i;
-            continue;
-        }
-        break;
-    }
-    return { node: ifNode, end };
-}
-// source: https://github.com/vuejs/core/blob/25ebe3a42cd80ac0256355c2740a0258cdd7419d/packages/compiler-core/src/transforms/vIf.ts#L207
-function createIfBranch(node, dir) {
-    const isTemplateIf = node.tagType === CompilerDOM.ElementTypes.TEMPLATE;
-    return {
-        type: CompilerDOM.NodeTypes.IF_BRANCH,
-        loc: node.loc,
-        condition: dir.name === 'else' ? undefined : dir.exp,
-        children: isTemplateIf && !CompilerDOM.findDir(node, 'for') && !CompilerDOM.findDir(node, 'slot')
-            ? node.children
-            : [node],
-        userKey: CompilerDOM.findProp(node, 'key'),
-        isTemplateIf,
-    };
-}
-function getVElseDirective(node) {
-    if (node.type !== CompilerDOM.NodeTypes.ELEMENT) {
-        return;
-    }
-    const directive = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-        && (prop.name === 'else-if' || prop.name === 'else'));
-    if (directive) {
-        return {
-            element: node,
-            directive,
-        };
-    }
-}
-function getVForNode(node, transformContext) {
-    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-        && prop.name === 'for');
-    if (forDirective) {
-        let forNode;
-        CompilerDOM.processFor(node, forDirective, transformContext, _forNode => {
-            forNode = { ..._forNode };
-            return undefined;
-        });
-        if (forNode) {
-            forNode.children = [{
-                    ...node,
-                    props: node.props.filter(prop => prop !== forDirective),
-                }];
-            return forNode;
-        }
-    }
-}
-function getVIfNode(node, transformContext) {
-    const ifDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-        && prop.name === 'if');
-    if (ifDirective) {
-        let ifNode;
-        CompilerDOM.processIf(node, ifDirective, transformContext, _ifNode => {
-            ifNode = { ..._ifNode };
-            return undefined;
-        });
-        if (ifNode) {
-            for (const branch of ifNode.branches) {
-                branch.children = [{
-                        ...node,
-                        props: node.props.filter(prop => prop !== ifDirective),
-                    }];
-            }
-            return ifNode;
-        }
-    }
-}
-//# sourceMappingURL=normalize.js.map

scripts/generate-names.js

-// @ts-check
-const { readFile, writeFile } = require('node:fs/promises');
-const { join } = require('node:path');
-
-generateNames();
-
-async function generateNames() {
-	const typePath = join(__dirname, '../types/template-helpers.d.ts');
-	const typeText = await readFile(typePath, 'utf-8');
-
-	/** @type {Set<string>} */
-	const pascalNames = new Set();
-	/** @type {Set<string>} */
-	const camelNames = new Set();
-
-	const declReg = /(?<=const\s+)\w*?(?=:)|(?<=type\s+)\w*?(?=\s*=|<)|(?<=function\s+)\w*?(?=\(|<)/g;
-	const prefix = '__VLS_';
-
-	for (const match of typeText.matchAll(declReg)) {
-		const name = match[0].slice(prefix.length);
-		if (name[0]?.toUpperCase() === name[0]) {
-			pascalNames.add(name);
-		}
-		else {
-			camelNames.add(name);
-		}
-	}
-
-	const namesPath = join(__dirname, '../lib/codegen/names.ts');
-	const namesText = await readFile(namesPath, 'utf-8');
-
-	await writeFile(
-		namesPath,
-		namesText.replace(
-			/(?<=\/\/ #region .*\n).*?(?=\t\/\/ #endregion)/ms,
-			[...camelNames].sort().map(name => `\t${name}: '',\n`).join('')
-				+ '\n'
-				+ [...pascalNames].sort().map(name => `\t${name}: '',\n`).join(''),
-		),
-	);
-}

New alerts

AI-detected potential code anomaly

Supply chain risk

AI has identified unusual behaviors that may pose a security risk.

Found 1 instance in 1 package

Fixed alerts

AI-detected potential code anomaly

Supply chain risk

AI has identified unusual behaviors that may pose a security risk.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

390748

1.11%

Number of package files

156

6.12%

Lines of code

8951

0.72%

Dependency changes

• Updated

  alien-signals@^3.2.0