@dcloudio/uni-mp-compiler 0.0.1-nvue3.3030820220125001

package/dist/transforms/utils.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeAttribute = exports.isStaticLiteral = exports.isReferencedByIds = exports.findReferencedScope = exports.rewriteExpression = exports.rewriteExpressionWithoutProperty = exports.parseExprWithRewriteClass = exports.parseExprWithRewrite = exports.rewirteWithHelper = exports.rewriteSpreadElement = exports.SCOPED_SLOT_IDENTIFIER = exports.ATTR_COM_TYPE = exports.ATTR_VUE_REF_IN_FOR = exports.ATTR_VUE_REF = exports.ATTR_VUE_PROPS = exports.ATTR_VUE_SLOTS = exports.ATTR_VUE_ID = void 0;
+const types_1 = require("@babel/types");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const estree_walker_1 = require("estree-walker");
+const ast_1 = require("../ast");
+const codegen_1 = require("../codegen");
+const transform_1 = require("../transform");
+// v-i,v-s 不能在 quickapp-webview 中使用，估计是内部处理成了指令之类的
+exports.ATTR_VUE_ID = 'u-i';
+exports.ATTR_VUE_SLOTS = 'u-s';
+exports.ATTR_VUE_PROPS = 'u-p';
+exports.ATTR_VUE_REF = 'u-' + uni_cli_shared_1.VUE_REF;
+exports.ATTR_VUE_REF_IN_FOR = 'u-' + uni_cli_shared_1.VUE_REF_IN_FOR;
+exports.ATTR_COM_TYPE = 'u-t';
+exports.SCOPED_SLOT_IDENTIFIER = '__SCOPED_SLOT__';
+function rewriteSpreadElement(name, expr, loc, context) {
+    return rewirteWithHelper(name, expr.argument, loc, context);
+}
+exports.rewriteSpreadElement = rewriteSpreadElement;
+function rewirteWithHelper(name, expr, loc, context) {
+    return parseExprWithRewrite(context.helperString(name) + '(' + (0, codegen_1.genBabelExpr)(expr) + ')', loc, context);
+}
+exports.rewirteWithHelper = rewirteWithHelper;
+function parseExprWithRewrite(code, loc, context, node) {
+    return (0, ast_1.parseExpr)(rewriteExpression((0, compiler_core_1.createSimpleExpression)(code, false, loc), context, node), context);
+}
+exports.parseExprWithRewrite = parseExprWithRewrite;
+function parseExprWithRewriteClass(code, loc, context, node) {
+    // a?1:0
+    return (0, ast_1.parseExpr)(rewriteExpression((0, compiler_core_1.createSimpleExpression)(code, false, loc), context, !(0, ast_1.isUndefined)(node)
+        ? (0, types_1.conditionalExpression)(node, (0, types_1.numericLiteral)(1), (0, types_1.stringLiteral)(''))
+        : node), context);
+}
+exports.parseExprWithRewriteClass = parseExprWithRewriteClass;
+function rewriteExpressionWithoutProperty(node, context, babelNode, scope = context.currentScope) {
+    return rewriteExpression(node, context, babelNode, scope, {
+        property: false,
+        ignoreLiteral: false,
+    });
+}
+exports.rewriteExpressionWithoutProperty = rewriteExpressionWithoutProperty;
+function rewriteExpression(node, context, babelNode, scope = context.currentScope, { property, ignoreLiteral, referencedScope, } = {
+    property: true,
+    ignoreLiteral: false,
+}) {
+    var _a;
+    if (node.type === 4 /* SIMPLE_EXPRESSION */ && node.isStatic) {
+        return node;
+    }
+    if (!babelNode) {
+        const code = (0, codegen_1.genExpr)(node);
+        babelNode = (0, ast_1.parseExpr)(code, context, node);
+        if (!babelNode) {
+            return (0, compiler_core_1.createSimpleExpression)(code);
+        }
+    }
+    if (!ignoreLiteral && isStaticLiteral(babelNode)) {
+        return node;
+    }
+    if ((0, ast_1.isUndefined)(babelNode)) {
+        return (0, compiler_core_1.createSimpleExpression)('undefined', false, node.loc);
+    }
+    // wxs 等表达式
+    if ((_a = context.filters) === null || _a === void 0 ? void 0 : _a.length) {
+        if (isReferencedByIds(babelNode, context.filters)) {
+            return (0, compiler_core_1.createSimpleExpression)((0, codegen_1.genExpr)(node), false, node.loc);
+        }
+    }
+    referencedScope = referencedScope || findReferencedScope(babelNode, scope);
+    const id = referencedScope.id.next();
+    if (property) {
+        referencedScope.properties.push((0, types_1.objectProperty)((0, types_1.identifier)(id), babelNode));
+    }
+    // 在 v-for 中包含的 v-if 块，所有变量需要补充当前 v-for value 前缀
+    if ((0, transform_1.isVIfScope)(referencedScope)) {
+        if ((0, transform_1.isVForScope)(referencedScope.parentScope)) {
+            return (0, compiler_core_1.createSimpleExpression)(referencedScope.parentScope.valueAlias + '.' + id);
+        }
+        return (0, compiler_core_1.createSimpleExpression)(id);
+    }
+    else if ((0, transform_1.isVForScope)(referencedScope)) {
+        return (0, compiler_core_1.createSimpleExpression)(referencedScope.valueAlias + '.' + id);
+    }
+    return (0, compiler_core_1.createSimpleExpression)(id);
+}
+exports.rewriteExpression = rewriteExpression;
+function findReferencedScope(node, scope) {
+    if ((0, transform_1.isVIfScope)(scope)) {
+        return scope;
+    }
+    else if ((0, transform_1.isVForScope)(scope)) {
+        if (isReferencedByIds(node, scope.locals)) {
+            return scope;
+        }
+        return findReferencedScope(node, scope.parent);
+    }
+    return scope;
+}
+exports.findReferencedScope = findReferencedScope;
+function isReferencedByIds(node, knownIds) {
+    let referenced = false;
+    (0, estree_walker_1.walk)(node, {
+        enter(node, parent) {
+            if (referenced) {
+                return this.skip();
+            }
+            if (!(0, types_1.isIdentifier)(node)) {
+                return;
+            }
+            if (knownIds.includes(node.name) &&
+                (!parent || (0, types_1.isReferenced)(node, parent))) {
+                referenced = true;
+                return this.skip();
+            }
+        },
+    });
+    return referenced;
+}
+exports.isReferencedByIds = isReferencedByIds;
+function isStaticLiteral(value) {
+    return (0, types_1.isLiteral)(value) && !(0, types_1.isTemplateLiteral)(value);
+}
+exports.isStaticLiteral = isStaticLiteral;
+function removeAttribute(node, name) {
+    const index = node.props.findIndex((prop) => prop.name === name);
+    if (index > -1) {
+        node.props.splice(index, 1);
+    }
+}
+exports.removeAttribute = removeAttribute;

package/dist/transforms/vBind.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveTransform } from '../transform';
+export declare const transformBind: DirectiveTransform;

package/dist/transforms/vBind.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBind = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const errors_1 = require("../errors");
+const transformBind = (dir, _node, context) => {
+    const { exp, modifiers, loc } = dir;
+    const arg = dir.arg;
+    if (arg.type !== 4 /* SIMPLE_EXPRESSION */) {
+        arg.children.unshift(`(`);
+        arg.children.push(`) || ""`);
+    }
+    else if (!arg.isStatic) {
+        arg.content = `${arg.content} || ""`;
+    }
+    // .sync is replaced by v-model:arg
+    if (modifiers.includes('camel')) {
+        if (arg.type === 4 /* SIMPLE_EXPRESSION */) {
+            if (arg.isStatic) {
+                arg.content = (0, shared_1.camelize)(arg.content);
+            }
+            else {
+                // arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`
+            }
+        }
+        else {
+            // arg.children.unshift(`${context.helperString(CAMELIZE)}(`)
+            // arg.children.push(`)`)
+        }
+    }
+    if (modifiers.includes('prop')) {
+        context.onWarn((0, errors_1.createMPCompilerError)(4 /* X_V_BIND_MODIFIER_PROP */, loc));
+    }
+    if (modifiers.includes('attr')) {
+        context.onWarn((0, errors_1.createMPCompilerError)(5 /* X_V_BIND_MODIFIER_ATTR */, loc));
+    }
+    if (!exp ||
+        (exp.type === 4 /* SIMPLE_EXPRESSION */ && !exp.content.trim())) {
+        context.onError((0, compiler_core_1.createCompilerError)(34 /* X_V_BIND_NO_EXPRESSION */, loc));
+        return {
+            props: [(0, compiler_core_1.createObjectProperty)(arg, (0, compiler_core_1.createSimpleExpression)('', true, loc))],
+        };
+    }
+    return {
+        props: [(0, compiler_core_1.createObjectProperty)(arg, exp)],
+    };
+};
+exports.transformBind = transformBind;

package/dist/transforms/vFor.d.ts

@@ -0,0 +1,35 @@
+import { ExpressionNode, SimpleExpressionNode, ElementTypes, ElementNode } from '@vue/compiler-core';
+import { NodeTransform, TransformContext } from '../transform';
+import { Expression, Identifier, Pattern, RestElement } from '@babel/types';
+import { CodegenVForScope } from '../options';
+export declare type VForOptions = Omit<ForParseResult, 'tagType'> & {
+    sourceExpr?: Expression;
+    sourceAlias: string;
+    sourceCode: string;
+    valueCode: string;
+    valueExpr: Identifier | Pattern | RestElement;
+    valueAlias: string;
+    keyCode: string;
+    keyExpr: Identifier | Pattern | RestElement;
+    keyAlias: string;
+    indexCode: string;
+    indexExpr: Identifier | Pattern | RestElement;
+    indexAlias: string;
+};
+export declare type ForElementNode = ElementNode & {
+    vFor: VForOptions & {
+        source: ExpressionNode;
+    };
+};
+export declare function isForElementNode(node: unknown): node is ForElementNode;
+export declare const transformFor: NodeTransform;
+export interface ForParseResult {
+    source: ExpressionNode;
+    value: ExpressionNode;
+    key: ExpressionNode;
+    index: ExpressionNode;
+    tagType: ElementTypes;
+}
+export declare function parseForExpression(input: SimpleExpressionNode, context: TransformContext): ForParseResult | undefined;
+export declare function createForLoopParams({ value, key, index }: ForParseResult, memoArgs?: ExpressionNode[]): ExpressionNode[];
+export declare function createVForArrowFunctionExpression({ valueExpr, keyExpr, indexExpr, properties, }: CodegenVForScope): import("@babel/types").ArrowFunctionExpression;

package/dist/transforms/vFor.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVForArrowFunctionExpression = exports.createForLoopParams = exports.parseForExpression = exports.transformFor = exports.isForElementNode = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const ast_1 = require("../ast");
+const transform_1 = require("../transform");
+const transformExpression_1 = require("./transformExpression");
+const codegen_1 = require("../codegen");
+const types_1 = require("@babel/types");
+const utils_1 = require("./utils");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const vSlot_1 = require("./vSlot");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function isForElementNode(node) {
+    return !!node.vFor;
+}
+exports.isForElementNode = isForElementNode;
+exports.transformFor = (0, transform_1.createStructuralDirectiveTransform)('for', (node, dir, context) => {
+    if (!dir.exp) {
+        context.onError((0, compiler_core_1.createCompilerError)(31 /* X_V_FOR_NO_EXPRESSION */, dir.loc));
+        return;
+    }
+    const parseResult = parseForExpression(dir.exp, context);
+    if (!parseResult) {
+        context.onError((0, compiler_core_1.createCompilerError)(32 /* X_V_FOR_MALFORMED_EXPRESSION */, dir.loc));
+        return;
+    }
+    parseResult.tagType = node.tagType;
+    const { addIdentifiers, removeIdentifiers } = context;
+    const { source, value, key, index } = parseResult;
+    if (context.prefixIdentifiers) {
+        addIdentifiers(value);
+        addIdentifiers(key);
+        addIdentifiers(index);
+    }
+    const { currentScope: parentScope, scopes, popScope } = context;
+    const sourceExpr = (0, ast_1.parseExpr)(source, context);
+    const valueCode = (0, codegen_1.genExpr)(value);
+    const valueExpr = (0, ast_1.parseParam)(valueCode, context, value);
+    const valueAlias = parseAlias(valueExpr, valueCode, 'v' + scopes.vFor);
+    const keyCode = (0, codegen_1.genExpr)(key);
+    const keyExpr = (0, ast_1.parseParam)(keyCode, context, key);
+    const keyAlias = parseAlias(keyExpr, keyCode, 'k' + scopes.vFor);
+    const indexCode = (0, codegen_1.genExpr)(index);
+    const indexExpr = (0, ast_1.parseParam)(indexCode, context, index);
+    const indexAlias = parseAlias(indexExpr, indexCode, 'i' + scopes.vFor);
+    // 先占位 vFor，后续更新 cloneSourceExpr 为 CallExpression
+    const cloneSourceExpr = (0, types_1.cloneNode)(sourceExpr, false);
+    const sourceAliasReferencedScope = (0, utils_1.findReferencedScope)(cloneSourceExpr, context.currentScope);
+    // 寻找子节点中 if 指令作用域
+    const vIfReferencedScope = findVIfReferencedScope(node, context.currentScope, context);
+    // 取最近的作用域
+    const referencedScope = vIfReferencedScope &&
+        context.getScopeIndex(vIfReferencedScope) >
+            context.getScopeIndex(sourceAliasReferencedScope)
+        ? vIfReferencedScope
+        : sourceAliasReferencedScope;
+    const sourceAlias = (0, utils_1.rewriteExpression)(source, context, cloneSourceExpr, parentScope, 
+    // 强制 rewrite，因为即使是字符串，数字，也要走 vFor 函数
+    {
+        property: true,
+        ignoreLiteral: true,
+        referencedScope,
+    }).content;
+    const sourceCode = `{{${sourceAlias}}}`;
+    const vForData = {
+        source,
+        sourceExpr,
+        sourceAlias,
+        sourceCode,
+        value,
+        valueCode,
+        valueExpr,
+        valueAlias,
+        key,
+        keyCode,
+        keyExpr,
+        keyAlias,
+        index,
+        indexCode,
+        indexExpr,
+        indexAlias,
+    };
+    const vForScope = context.addVForScope({
+        ...vForData,
+        locals: findVForLocals(parseResult),
+    });
+    const vFor = {
+        ...vForData,
+    };
+    const isScopedSlot = (0, transform_1.isScopedSlotVFor)(vForScope);
+    node.vFor = vFor;
+    scopes.vFor++;
+    return () => {
+        scopes.vFor--;
+        if ((0, compiler_core_1.isTemplateNode)(node)) {
+            node.children.some((c) => {
+                if (c.type === 1 /* ELEMENT */ && !isForElementNode(c)) {
+                    const key = (0, compiler_core_1.findProp)(c, 'key');
+                    if (key) {
+                        context.onError((0, compiler_core_1.createCompilerError)(33 /* X_V_FOR_TEMPLATE_KEY_PLACEMENT */, key.loc));
+                        return true;
+                    }
+                }
+            });
+        }
+        if (context.prefixIdentifiers) {
+            value && removeIdentifiers(value);
+            key && removeIdentifiers(key);
+            index && removeIdentifiers(index);
+        }
+        (0, shared_1.extend)(clearExpr(cloneSourceExpr), isScopedSlot
+            ? (0, vSlot_1.createVSlotCallExpression)(node
+                .slotComponent, vForScope, context)
+            : createVForCallExpression(vForScope, context));
+        popScope();
+    };
+});
+function clearExpr(expr) {
+    Object.keys(expr).forEach((key) => {
+        delete expr[key];
+    });
+    return expr;
+}
+function parseAlias(babelExpr, exprCode, fallback) {
+    if ((0, types_1.isIdentifier)(babelExpr)) {
+        return exprCode;
+    }
+    return fallback;
+}
+function parseVForScope(currentScope) {
+    while (currentScope) {
+        if ((0, transform_1.isVForScope)(currentScope) && !(0, transform_1.isScopedSlotVFor)(currentScope)) {
+            return currentScope;
+        }
+        currentScope = currentScope.parent;
+    }
+}
+function findVIfReferencedScope(node, currentScope, context) {
+    if (!currentScope) {
+        return;
+    }
+    const vForScope = parseVForScope(currentScope);
+    if (!vForScope) {
+        return;
+    }
+    if (!node.children.find((item) => checkVIfReferenced(item, vForScope, context))) {
+        return findVIfReferencedScope(node, currentScope.parent, context);
+    }
+    return vForScope;
+}
+function checkVIfReferenced(node, vForScope, context) {
+    if (!(0, uni_cli_shared_1.isElementNode)(node)) {
+        return false;
+    }
+    // 嵌套 for 不查找
+    if ((0, compiler_core_1.findDir)(node, 'for')) {
+        return false;
+    }
+    const ifDir = (0, compiler_core_1.findDir)(node, 'if');
+    if (ifDir) {
+        return checkDirReferenced(ifDir.exp, vForScope, context);
+    }
+    const elseIfDir = (0, compiler_core_1.findDir)(node, 'else-if');
+    if (elseIfDir) {
+        return checkDirReferenced(elseIfDir.exp, vForScope, context);
+    }
+    return !!node.children.find((item) => checkVIfReferenced(item, vForScope, context));
+}
+function checkDirReferenced(node, vForScope, context) {
+    if (node) {
+        const babelNode = (0, ast_1.parseExpr)(node, context);
+        if (babelNode && (0, utils_1.isReferencedByIds)(babelNode, vForScope.locals)) {
+            return true;
+        }
+    }
+    return false;
+}
+function findVForLocals({ value, key, index }) {
+    const ids = [];
+    if (value) {
+        findIds(value, ids);
+    }
+    if (key) {
+        findIds(key, ids);
+    }
+    if (index) {
+        findIds(index, ids);
+    }
+    return ids;
+}
+function findIds(exp, ids) {
+    if ((0, shared_1.isString)(exp)) {
+        ids.push(exp);
+    }
+    else if (exp.identifiers) {
+        exp.identifiers.forEach((id) => ids.push(id));
+    }
+    else if (exp.type === 4 /* SIMPLE_EXPRESSION */) {
+        ids.push(exp.content);
+    }
+}
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+function parseForExpression(input, context) {
+    const loc = input.loc;
+    const exp = input.content;
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const [, LHS, RHS] = inMatch;
+    const result = {
+        source: createAliasExpression(loc, RHS.trim(), exp.indexOf(RHS, LHS.length)),
+        value: (0, compiler_core_1.createSimpleExpression)('v' + context.scopes.vFor),
+        key: (0, compiler_core_1.createSimpleExpression)('k' + context.scopes.vFor),
+        index: (0, compiler_core_1.createSimpleExpression)('i' + context.scopes.vFor),
+        tagType: 0 /* ELEMENT */,
+    };
+    if (context.prefixIdentifiers) {
+        result.source = (0, transformExpression_1.processExpression)(result.source, context);
+    }
+    let valueContent = LHS.trim().replace(stripParensRE, '').trim();
+    const trimmedOffset = LHS.indexOf(valueContent);
+    const iteratorMatch = valueContent.match(forIteratorRE);
+    if (iteratorMatch) {
+        valueContent = valueContent.replace(forIteratorRE, '').trim();
+        const keyContent = iteratorMatch[1].trim();
+        let keyOffset;
+        if (keyContent) {
+            keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
+            result.key = createAliasExpression(loc, keyContent, keyOffset);
+            if (context.prefixIdentifiers) {
+                result.key = (0, transformExpression_1.processExpression)(result.key, context, true);
+            }
+        }
+        if (iteratorMatch[2]) {
+            const indexContent = iteratorMatch[2].trim();
+            if (indexContent) {
+                result.index = createAliasExpression(loc, indexContent, exp.indexOf(indexContent, result.key
+                    ? keyOffset + keyContent.length
+                    : trimmedOffset + valueContent.length));
+                if (context.prefixIdentifiers) {
+                    result.index = (0, transformExpression_1.processExpression)(result.index, context, true);
+                }
+            }
+        }
+    }
+    if (valueContent) {
+        result.value = createAliasExpression(loc, valueContent, trimmedOffset);
+        if (context.prefixIdentifiers) {
+            result.value = (0, transformExpression_1.processExpression)(result.value, context, true);
+        }
+    }
+    return result;
+}
+exports.parseForExpression = parseForExpression;
+function createAliasExpression(range, content, offset) {
+    return (0, compiler_core_1.createSimpleExpression)(content, false, (0, compiler_core_1.getInnerRange)(range, offset, content.length));
+}
+function createForLoopParams({ value, key, index }, memoArgs = []) {
+    return createParamsList([value, key, index, ...memoArgs]);
+}
+exports.createForLoopParams = createForLoopParams;
+function createParamsList(args) {
+    let i = args.length;
+    while (i--) {
+        if (args[i])
+            break;
+    }
+    return args
+        .slice(0, i + 1)
+        .map((arg, i) => arg || (0, compiler_core_1.createSimpleExpression)(`_`.repeat(i + 1), false));
+}
+function createVForCallExpression(vForScope, context) {
+    // let sourceExpr: Expression = vForScope.sourceExpr!
+    // if (isNumericLiteral(sourceExpr)) {
+    //   sourceExpr = numericLiteralToArrayExpr((sourceExpr as NumericLiteral).value)
+    // }
+    return (0, types_1.callExpression)((0, types_1.identifier)(context.helperString(runtimeHelpers_1.V_FOR)), [
+        vForScope.sourceExpr,
+        createVForArrowFunctionExpression(vForScope),
+    ]);
+}
+function createVForArrowFunctionExpression({ valueExpr, keyExpr, indexExpr, properties, }) {
+    const params = [];
+    if (valueExpr) {
+        params.push(valueExpr);
+    }
+    if (keyExpr) {
+        params.push(keyExpr);
+    }
+    if (indexExpr) {
+        params.push(indexExpr);
+    }
+    return (0, types_1.arrowFunctionExpression)(params, (0, types_1.blockStatement)([(0, types_1.returnStatement)((0, types_1.objectExpression)(properties))]));
+}
+exports.createVForArrowFunctionExpression = createVForArrowFunctionExpression;

package/dist/transforms/vHtml.d.ts

@@ -0,0 +1,2 @@
+import { NodeTransform } from '../transform';
+export declare const transformHtml: NodeTransform;

package/dist/transforms/vHtml.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformHtml = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const transformHtml = (node, _) => {
+    if (!(0, uni_cli_shared_1.isElementNode)(node)) {
+        return;
+    }
+    const dir = (0, compiler_core_1.findDir)(node, 'html');
+    if (!dir) {
+        return;
+    }
+    // remove v-html
+    node.props.splice(node.props.indexOf(dir), 1);
+    if (node.tagType !== 0 /* ELEMENT */) {
+        return;
+    }
+    node.isSelfClosing = false;
+    node.children = [createRichText(node, dir)];
+};
+exports.transformHtml = transformHtml;
+function createRichText(node, dir) {
+    return {
+        tag: 'rich-text',
+        type: 1 /* ELEMENT */,
+        tagType: 0 /* ELEMENT */,
+        props: [(0, uni_cli_shared_1.createBindDirectiveNode)('nodes', dir.exp || '')],
+        isSelfClosing: true,
+        children: [],
+        codegenNode: undefined,
+        ns: node.ns,
+        loc: node.loc,
+    };
+}

package/dist/transforms/vIf.d.ts

@@ -0,0 +1,13 @@
+import { DirectiveNode, ElementNode, IfNode } from '@vue/compiler-core';
+import { NodeTransform, TransformContext } from '../transform';
+interface IfOptions {
+    name: string;
+    condition?: string;
+}
+export declare type IfElementNode = ElementNode & {
+    vIf: IfOptions;
+};
+export declare function isIfElementNode(node: unknown): node is IfElementNode;
+export declare const transformIf: NodeTransform;
+export declare function processIf(node: ElementNode, dir: DirectiveNode, context: TransformContext, processCodegen?: (node: IfNode, branch: IfElementNode, isRoot: boolean) => (() => void) | undefined): (() => void) | undefined;
+export {};