@vue/language-core 3.2.7 → 3.2.9

package/lib/codegen/template/vFor.js

@@ -38,6 +38,7 @@ exports.parseVForNode = parseVForNode;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const collectBindings_1 = require("../../utils/collectBindings");
 const codeFeatures_1 = require("../codeFeatures");
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
@@ -58,7 +59,7 @@ function* generateVFor(options, ctx, node) {
     }
     yield `] of `;
     if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        yield `__VLS_vFor(`;
+        yield `${names_1.names.vFor}(`;
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, source.content, source.loc.start.offset, `(`, `)`);
         yield `!)`; // #3102
     }
@@ -66,28 +67,10 @@ function* generateVFor(options, ctx, node) {
         yield `{} as any`;
     }
     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);
     }
     ctx.inVFor = inVFor;
     yield* endScope();

package/lib/codegen/template/vIf.js

@@ -42,10 +42,6 @@ const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
 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) {
@@ -67,7 +63,7 @@ function* generateVIf(options, ctx, node) {
         }
         yield `{${utils_1.newLine}`;
         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);
         }
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {

package/lib/codegen/template/vSlot.js

@@ -38,6 +38,7 @@ const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const muggle_string_1 = require("muggle-string");
 const collectBindings_1 = require("../../utils/collectBindings");
 const codeFeatures_1 = require("../codeFeatures");
+const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const interpolation_1 = require("./interpolation");
@@ -125,7 +126,7 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     }
     yield `const [`;
     yield* interpolation;
-    yield `] = __VLS_vSlot(${slotVar}!`;
+    yield `] = ${names_1.names.vSlot}(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
         const token = yield* (0, boundary_1.startBoundary)('template', exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);

package/lib/languagePlugin.js

@@ -38,6 +38,7 @@ exports.createVueLanguagePlugin = createVueLanguagePlugin;
 exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const LanguageCore = __importStar(require("../index"));
 const plugins_1 = require("./plugins");
 const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};
@@ -60,6 +61,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
     const pluginContext = {
         modules: {
             '@vue/compiler-dom': CompilerDOM,
+            '@vue/language-core': LanguageCore,
             typescript: ts,
         },
         compilerOptions,

package/lib/plugins/file-md.js

@@ -5,14 +5,13 @@ const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 const parseSfc_1 = require("../utils/parseSfc");
 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 }) => {
     return {
         version: 2.2,
@@ -28,32 +27,29 @@ const plugin = ({ vueCompilerOptions }) => {
             if (languageId !== 'markdown') {
                 return;
             }
-            content = content
-                // frontmatter
-                .replace(frontmatterReg, match => ' '.repeat(match.length))
-                // code block
-                .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
-                .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);
+            }
+            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);
+                }
             }
-            content = content
-                // angle bracket: <http://foo.com>
-                .replace(angleBracketReg, match => ' '.repeat(match.length))
-                // [foo](http://foo.com)
-                .replace(linkReg, match => ' '.repeat(match.length));
             codes.push('<template>\n');
             codes.push([content, undefined, 0]);
             codes.push('\n</template>');

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

@@ -1,8 +1,42 @@
 "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 {
         version: 2.2,
         compileSFCTemplate(lang, template, options) {
@@ -13,11 +47,7 @@ const plugin = ({ modules }) => {
                     template += '>';
                     addedSuffix = true;
                 }
-                const ast = CompilerDOM.parse(template, {
-                    ...options,
-                    comments: true,
-                });
-                CompilerDOM.transform(ast, options);
+                const ast = (0, compile_1.compileTemplate)(template, options);
                 return {
                     ast,
                     code: '',
@@ -97,11 +127,6 @@ const plugin = ({ modules }) => {
                             return false;
                         }
                     }
-                    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-                        if (!tryUpdateNode(node.content)) {
-                            return false;
-                        }
-                    }
                     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
                         for (const childNode of node.children) {
                             if (typeof childNode === 'object') {

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

@@ -178,10 +178,6 @@ const plugin = ({ modules: { typescript: ts } }) => {
                     visit(child);
                 }
             }
-            else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-                // {{ var }}
-                visit(node.content);
-            }
             else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
                 // {{ ... }} {{ ... }}
                 for (const childNode of node.children) {

package/lib/plugins/vue-tsx.js

@@ -206,28 +206,11 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         if (!allVars.size) {
             return allVars;
         }
-        const exposedNames = new Set();
-        const generatedTemplate = getGeneratedTemplate();
-        const generatedStyle = getGeneratedStyle();
-        for (const [name] of generatedTemplate?.componentAccessMap ?? []) {
-            if (allVars.has(name)) {
-                exposedNames.add(name);
-            }
-        }
-        for (const [name] of generatedStyle?.componentAccessMap ?? []) {
-            if (allVars.has(name)) {
-                exposedNames.add(name);
-            }
-        }
-        for (const component of sfc.template?.ast?.components ?? []) {
-            const testNames = new Set([(0, shared_1.camelize)(component), (0, shared_1.capitalize)((0, shared_1.camelize)(component))]);
-            for (const testName of testNames) {
-                if (allVars.has(testName)) {
-                    exposedNames.add(testName);
-                }
-            }
-        }
-        return exposedNames;
+        return new Set([
+            ...getGeneratedTemplate()?.componentAccessMap.keys() ?? [],
+            ...getGeneratedStyle()?.componentAccessMap.keys() ?? [],
+            ...sfc.template?.ast?.components.flatMap(name => [(0, shared_1.camelize)(name), (0, shared_1.capitalize)((0, shared_1.camelize)(name))]) ?? [],
+        ].filter(name => allVars.has(name)));
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
         return (0, script_1.generateScript)({

package/lib/template/compile.d.ts

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

package/lib/template/compile.js

@@ -0,0 +1,31 @@
+"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

package/lib/template/transforms/transformElement.d.ts

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

package/lib/template/transforms/transformElement.js

@@ -0,0 +1,95 @@
+"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

package/lib/template/transforms/transformText.d.ts

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

package/lib/template/transforms/transformText.js

@@ -0,0 +1,35 @@
+"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

package/lib/template/transforms/vFor.d.ts

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

package/lib/template/transforms/vFor.js

@@ -0,0 +1,42 @@
+"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

package/lib/template/transforms/vIf.d.ts

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

package/lib/template/transforms/vIf.js

@@ -0,0 +1,92 @@
+"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

package/lib/template/utils.d.ts

@@ -0,0 +1,3 @@
+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;

package/lib/template/utils.js

@@ -0,0 +1,37 @@
+"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