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

package/dist/transform.js

@@ -0,0 +1,518 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStructuralDirectiveTransform = exports.createTransformContext = exports.traverseChildren = exports.traverseNode = exports.transform = exports.isScopedSlotVFor = exports.isVForScope = exports.isVIfScope = exports.isRootScope = void 0;
+const shared_1 = require("@vue/shared");
+const types_1 = require("@babel/types");
+const compiler_core_1 = require("@vue/compiler-core");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const identifier_1 = __importDefault(require("./identifier"));
+const runtimeHelpers_1 = require("./runtimeHelpers");
+const ast_1 = require("./ast");
+const utils_1 = require("./transforms/utils");
+const codegen_1 = require("./codegen");
+function isRootScope(scope) {
+    return !isVIfScope(scope) && !isVForScope(scope);
+}
+exports.isRootScope = isRootScope;
+function isVIfScope(scope) {
+    return (!!scope.condition ||
+        scope.name === 'else');
+}
+exports.isVIfScope = isVIfScope;
+function isVForScope(scope) {
+    return !!scope.source;
+}
+exports.isVForScope = isVForScope;
+function isScopedSlotVFor({ source }) {
+    if (source.type !== 8 /* COMPOUND_EXPRESSION */) {
+        return false;
+    }
+    const first = source.children[0];
+    return (first.type === 4 /* SIMPLE_EXPRESSION */ &&
+        first.content.includes(utils_1.SCOPED_SLOT_IDENTIFIER));
+}
+exports.isScopedSlotVFor = isScopedSlotVFor;
+function transform(root, options) {
+    const context = createTransformContext(root, options);
+    traverseNode(root, context);
+    root.renderData = createRenderDataExpr(context.scope.properties, context);
+    // finalize meta information
+    root.helpers = [...context.helpers.keys()];
+    root.components = [...context.components];
+    root.imports = context.imports;
+    root.cached = context.cached;
+    return context;
+}
+exports.transform = transform;
+function traverseNode(node, context) {
+    context.currentNode = node;
+    // apply transform plugins
+    const { nodeTransforms } = context;
+    const exitFns = [];
+    for (let i = 0; i < nodeTransforms.length; i++) {
+        const onExit = nodeTransforms[i](node, context);
+        if (onExit) {
+            if ((0, shared_1.isArray)(onExit)) {
+                exitFns.push(...onExit);
+            }
+            else {
+                exitFns.push(onExit);
+            }
+        }
+        if (!context.currentNode) {
+            // node was removed
+            return;
+        }
+        else {
+            // node may have been replaced
+            node = context.currentNode;
+        }
+    }
+    switch (node.type) {
+        case 3 /* COMMENT */:
+            // context.helper(CREATE_COMMENT)
+            break;
+        case 5 /* INTERPOLATION */:
+            context.helper(compiler_core_1.TO_DISPLAY_STRING);
+            break;
+        // for container types, further traverse downwards
+        case 9 /* IF */:
+            for (let i = 0; i < node.branches.length; i++) {
+                traverseNode(node.branches[i], context);
+            }
+            break;
+        case 10 /* IF_BRANCH */:
+        case 11 /* FOR */:
+        case 1 /* ELEMENT */:
+        case 0 /* ROOT */:
+            traverseChildren(node, context);
+            break;
+    }
+    // exit transforms
+    context.currentNode = node;
+    let i = exitFns.length;
+    while (i--) {
+        exitFns[i]();
+    }
+}
+exports.traverseNode = traverseNode;
+function traverseChildren(parent, context) {
+    let i = 0;
+    const nodeRemoved = () => {
+        i--;
+    };
+    for (; i < parent.children.length; i++) {
+        const child = parent.children[i];
+        if ((0, shared_1.isString)(child))
+            continue;
+        context.parent = parent;
+        context.childIndex = i;
+        context.onNodeRemoved = nodeRemoved;
+        traverseNode(child, context);
+    }
+}
+exports.traverseChildren = traverseChildren;
+function defaultOnError(error) {
+    throw error;
+}
+function defaultOnWarn(msg) {
+    console.warn(`[Vue warn] ${msg.message}`);
+}
+function createTransformContext(rootNode, { root = '', filename = '', isTS = false, inline = false, hashId = null, scopeId = null, filters = [], bindingCssVars = [], bindingMetadata = shared_1.EMPTY_OBJ, cacheHandlers = false, prefixIdentifiers = false, skipTransformIdentifier = false, renderDataSpread = false, nodeTransforms = [], directiveTransforms = {}, miniProgram = {
+    class: {
+        array: true,
+    },
+    slot: {
+        fallbackContent: false,
+        dynamicSlotNames: true,
+    },
+    directive: '',
+}, isBuiltInComponent = shared_1.NOOP, isCustomElement = shared_1.NOOP, expressionPlugins = [], onError = defaultOnError, onWarn = defaultOnWarn, }) {
+    var _a;
+    const rootScope = {
+        id: new identifier_1.default(),
+        identifiers: [],
+        properties: [],
+        parent: null,
+    };
+    function findVIfParentScope() {
+        for (let i = scopes.length - 1; i >= 0; i--) {
+            const scope = scopes[i];
+            if (isVForScope(scope) || isRootScope(scope)) {
+                return scope;
+            }
+        }
+        return rootScope;
+    }
+    function createScope(id, initScope) {
+        return (0, shared_1.extend)({
+            id,
+            properties: [],
+            parent: scopes[scopes.length - 1],
+            get identifiers() {
+                return Object.keys(identifiers);
+            },
+        }, initScope);
+    }
+    const vueIds = [];
+    const identifiers = Object.create(null);
+    const scopes = [rootScope];
+    const miniProgramComponents = (0, uni_cli_shared_1.findMiniProgramUsingComponents)({
+        filename,
+        componentsDir: (_a = miniProgram.component) === null || _a === void 0 ? void 0 : _a.dir,
+        inputDir: root,
+    });
+    // const nameMatch = filename.replace(/\?.*$/, '').match(/([^/\\]+)\.\w+$/)
+    const context = {
+        // options
+        // 暂不提供根据文件名生成递归组件
+        selfName: '',
+        miniProgram,
+        isTS,
+        inline,
+        hashId,
+        scopeId,
+        filters,
+        bindingCssVars,
+        bindingMetadata,
+        cacheHandlers,
+        prefixIdentifiers,
+        nodeTransforms,
+        directiveTransforms,
+        expressionPlugins,
+        skipTransformIdentifier,
+        renderDataSpread,
+        isBuiltInComponent,
+        isCustomElement,
+        onError,
+        onWarn,
+        // state
+        parent: null,
+        childIndex: 0,
+        helpers: new Map(),
+        components: new Set(),
+        imports: [],
+        bindingComponents: Object.create(null),
+        cached: 0,
+        identifiers,
+        scope: rootScope,
+        scopes: {
+            vFor: 0,
+            vueId: 0,
+        },
+        get currentScope() {
+            return scopes[scopes.length - 1];
+        },
+        currentNode: rootNode,
+        vueIds,
+        get currentVueId() {
+            return vueIds[vueIds.length - 1];
+        },
+        inVOnce: false,
+        get inVFor() {
+            let parent = scopes[scopes.length - 1];
+            while (parent) {
+                if (isVForScope(parent) && !isScopedSlotVFor(parent)) {
+                    return true;
+                }
+                parent = parent.parent;
+            }
+            return false;
+        },
+        // methods
+        getScopeIndex(scope) {
+            return scopes.indexOf(scope);
+        },
+        popScope() {
+            return scopes.pop();
+        },
+        addVIfScope(initScope) {
+            const vIfScope = createScope(scopes[scopes.length - 1].id, (0, shared_1.extend)(initScope, { parentScope: findVIfParentScope() }));
+            scopes.push(vIfScope);
+            return vIfScope;
+        },
+        addVForScope(initScope) {
+            const vForScope = createScope(new identifier_1.default(), initScope);
+            scopes.push(vForScope);
+            return vForScope;
+        },
+        helper(name) {
+            const count = context.helpers.get(name) || 0;
+            context.helpers.set(name, count + 1);
+            return name;
+        },
+        removeHelper(name) {
+            const count = context.helpers.get(name);
+            if (count) {
+                const currentCount = count - 1;
+                if (!currentCount) {
+                    context.helpers.delete(name);
+                }
+                else {
+                    context.helpers.set(name, currentCount);
+                }
+            }
+        },
+        helperString(name) {
+            return `_${compiler_core_1.helperNameMap[context.helper(name)]}`;
+        },
+        replaceNode(node) {
+            context.parent.children[context.childIndex] = context.currentNode = node;
+        },
+        removeNode(node) {
+            if (!context.parent) {
+                throw new Error(`Cannot remove root node.`);
+            }
+            const list = context.parent.children;
+            const removalIndex = node
+                ? list.indexOf(node)
+                : context.currentNode
+                    ? context.childIndex
+                    : -1;
+            /* istanbul ignore if */
+            if (removalIndex < 0) {
+                throw new Error(`node being removed is not a child of current parent`);
+            }
+            if (!node || node === context.currentNode) {
+                // current node removed
+                context.currentNode = null;
+                context.onNodeRemoved();
+            }
+            else {
+                // sibling node removed
+                if (context.childIndex > removalIndex) {
+                    context.childIndex--;
+                    context.onNodeRemoved();
+                }
+            }
+            context.parent.children.splice(removalIndex, 1);
+        },
+        onNodeRemoved: () => { },
+        addIdentifiers(exp) {
+            if ((0, shared_1.isString)(exp)) {
+                addId(exp);
+            }
+            else if (exp.identifiers) {
+                exp.identifiers.forEach(addId);
+            }
+            else if (exp.type === 4 /* SIMPLE_EXPRESSION */) {
+                addId(exp.content);
+            }
+        },
+        removeIdentifiers(exp) {
+            if ((0, shared_1.isString)(exp)) {
+                removeId(exp);
+            }
+            else if (exp.identifiers) {
+                exp.identifiers.forEach(removeId);
+            }
+            else if (exp.type === 4 /* SIMPLE_EXPRESSION */) {
+                removeId(exp.content);
+            }
+        },
+        cache(exp, isVNode = false) {
+            return createCacheExpression(context.cached++, exp, isVNode);
+        },
+        isMiniProgramComponent(name) {
+            return miniProgramComponents.includes(name);
+        },
+    };
+    function addId(id) {
+        const { identifiers } = context;
+        if (identifiers[id] === undefined) {
+            identifiers[id] = 0;
+        }
+        identifiers[id]++;
+    }
+    function removeId(id) {
+        context.identifiers[id]--;
+    }
+    return context;
+}
+exports.createTransformContext = createTransformContext;
+function createCacheExpression(index, value, isVNode = false) {
+    return {
+        type: 20 /* JS_CACHE_EXPRESSION */,
+        index,
+        value,
+        isVNode,
+        loc: compiler_core_1.locStub,
+    };
+}
+function createStructuralDirectiveTransform(name, fn) {
+    const matches = (0, shared_1.isString)(name)
+        ? (n) => n === name
+        : (n) => name.test(n);
+    return (node, context) => {
+        if (node.type === 1 /* ELEMENT */) {
+            const { props } = node;
+            // structural directive transforms are not concerned with slots
+            // as they are handled separately in vSlot.ts
+            // if (node.tagType === ElementTypes.TEMPLATE && props.some(isVSlot)) {
+            //   return
+            // }
+            const exitFns = [];
+            for (let i = 0; i < props.length; i++) {
+                const prop = props[i];
+                if (prop.type === 7 /* DIRECTIVE */ && matches(prop.name)) {
+                    // structural directives are removed to avoid infinite recursion
+                    // also we remove them *before* applying so that it can further
+                    // traverse itself in case it moves the node around
+                    props.splice(i, 1);
+                    i--;
+                    const onExit = fn(node, prop, context);
+                    if (onExit)
+                        exitFns.push(onExit);
+                }
+            }
+            return exitFns;
+        }
+    };
+}
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
+function createRenderDataExpr(properties, context) {
+    const objExpr = (0, ast_1.createObjectExpression)(properties);
+    if (!hasSpreadElement(objExpr)) {
+        return objExpr;
+    }
+    // filters: ['test']
+    // v-if="text.aa()"
+    if (context.filters.length) {
+        transformFilterObjectSpreadExpr(objExpr, context);
+    }
+    if (context.renderDataSpread) {
+        return objExpr;
+    }
+    return transformObjectSpreadExpr(objExpr, context);
+}
+function hasSpreadElement(expr) {
+    return expr.properties.some((prop) => {
+        if ((0, types_1.isSpreadElement)(prop)) {
+            return true;
+        }
+        else {
+            const returnStatement = parseReturnStatement(prop);
+            if (returnStatement) {
+                return hasSpreadElement(returnStatement.argument);
+            }
+        }
+    });
+}
+// 目前硬编码识别 _f,应该读取 context.helperString
+const returnObjExprMap = {
+    _f: 1,
+    _w: 0, // _w(()=>{return {}})
+};
+function parseReturnStatement(prop) {
+    if ((0, types_1.isObjectProperty)(prop) &&
+        (0, types_1.isCallExpression)(prop.value) &&
+        (0, types_1.isIdentifier)(prop.value.callee)) {
+        const { name } = prop.value.callee;
+        if ((0, shared_1.hasOwn)(returnObjExprMap, name)) {
+            return prop.value.arguments[returnObjExprMap[name]].body.body[0];
+        }
+    }
+}
+function transformObjectPropertyExpr(prop, context) {
+    // vFor,withScopedSlot
+    const returnStatement = parseReturnStatement(prop);
+    if (returnStatement) {
+        const objExpr = returnStatement.argument;
+        if (hasSpreadElement(objExpr)) {
+            returnStatement.argument = transformObjectSpreadExpr(objExpr, context);
+        }
+    }
+    return prop;
+}
+function transformObjectSpreadExpr(objExpr, context) {
+    const properties = objExpr.properties;
+    const args = [];
+    let objExprProperties = [];
+    properties.forEach((prop) => {
+        if ((0, types_1.isObjectProperty)(prop)) {
+            objExprProperties.push(transformObjectPropertyExpr(prop, context));
+        }
+        else {
+            if (objExprProperties.length) {
+                args.push((0, types_1.objectExpression)(objExprProperties));
+            }
+            args.push(transformConditionalExpression(prop.argument, context));
+            objExprProperties = [];
+        }
+    });
+    if (objExprProperties.length) {
+        args.push((0, types_1.objectExpression)(objExprProperties));
+    }
+    if (args.length === 1) {
+        return args[0];
+    }
+    return (0, types_1.callExpression)((0, types_1.identifier)(context.helperString(runtimeHelpers_1.EXTEND)), args);
+}
+function transformConditionalExpression(expr, context) {
+    const { consequent, alternate } = expr;
+    if ((0, types_1.isObjectExpression)(consequent) && hasSpreadElement(consequent)) {
+        expr.consequent = transformObjectSpreadExpr(consequent, context);
+    }
+    if ((0, types_1.isObjectExpression)(alternate)) {
+        if (hasSpreadElement(alternate)) {
+            expr.alternate = transformObjectSpreadExpr(alternate, context);
+        }
+    }
+    else if ((0, types_1.isConditionalExpression)(alternate)) {
+        transformConditionalExpression(alternate, context);
+    }
+    return expr;
+}
+function transformFilterObjectSpreadExpr(objExpr, context) {
+    const properties = objExpr.properties;
+    properties.forEach((prop) => {
+        if ((0, types_1.isObjectProperty)(prop)) {
+            transformFilterObjectPropertyExpr(prop, context);
+        }
+        else {
+            prop.argument = transformFilterConditionalExpression(prop.argument, context);
+        }
+    });
+}
+function transformFilterObjectPropertyExpr(prop, context) {
+    // vFor, withScopedSlot
+    const returnStatement = parseReturnStatement(prop);
+    if (returnStatement) {
+        const objExpr = returnStatement.argument;
+        if (hasSpreadElement(objExpr)) {
+            transformFilterObjectSpreadExpr(objExpr, context);
+        }
+    }
+}
+function transformFilterConditionalExpression(expr, context) {
+    const { test, consequent, alternate } = expr;
+    if ((0, types_1.isObjectExpression)(consequent) && hasSpreadElement(consequent)) {
+        transformFilterObjectSpreadExpr(consequent, context);
+    }
+    if ((0, types_1.isObjectExpression)(alternate)) {
+        if (hasSpreadElement(alternate)) {
+            transformFilterObjectSpreadExpr(alternate, context);
+        }
+    }
+    else if ((0, types_1.isConditionalExpression)(alternate)) {
+        expr.alternate = transformFilterConditionalExpression(alternate, context);
+    }
+    const testCode = (0, codegen_1.genBabelExpr)(test);
+    // filter test
+    if (context.filters.find((filter) => testCode.includes(filter + '.'))) {
+        // test.aa() ? {a:1} : {b:2} => {...{a:1},...{b:2}}
+        const properties = [];
+        if (!(0, types_1.isObjectExpression)(consequent) || consequent.properties.length) {
+            properties.push((0, types_1.spreadElement)(consequent));
+        }
+        if (!(0, types_1.isObjectExpression)(expr.alternate) ||
+            expr.alternate.properties.length) {
+            properties.push((0, types_1.spreadElement)(expr.alternate));
+        }
+        return (0, types_1.objectExpression)(properties);
+    }
+    return expr;
+}

package/dist/transforms/transformClass.d.ts

@@ -0,0 +1,5 @@
+import { DirectiveNode, AttributeNode } from '@vue/compiler-core';
+import { TransformContext } from '../transform';
+export declare function isClassBinding({ arg }: DirectiveNode): boolean | undefined;
+export declare function findStaticClassIndex(props: (AttributeNode | DirectiveNode)[]): number;
+export declare function rewriteClass(index: number, classBindingProp: DirectiveNode, props: (AttributeNode | DirectiveNode)[], context: TransformContext): void;

package/dist/transforms/transformClass.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteClass = exports.findStaticClassIndex = exports.isClassBinding = void 0;
+const types_1 = require("@babel/types");
+const compiler_core_1 = require("@vue/compiler-core");
+const ast_1 = require("../ast");
+const codegen_1 = require("../codegen");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const utils_1 = require("./utils");
+function isClassBinding({ arg }) {
+    return (arg && arg.type === 4 /* SIMPLE_EXPRESSION */ && arg.content === 'class');
+}
+exports.isClassBinding = isClassBinding;
+function findStaticClassIndex(props) {
+    return props.findIndex((prop) => prop.name === 'class');
+}
+exports.findStaticClassIndex = findStaticClassIndex;
+function rewriteClass(index, classBindingProp, props, context) {
+    if (!classBindingProp.exp) {
+        return;
+    }
+    const expr = (0, ast_1.parseExpr)(classBindingProp.exp, context);
+    if (!expr) {
+        return;
+    }
+    let classBindingExpr = expr;
+    if ((0, types_1.isObjectExpression)(expr)) {
+        classBindingExpr = createClassBindingByObjectExpression(rewriteClassObjectExpression(expr, classBindingProp.loc, context));
+    }
+    else if ((0, types_1.isArrayExpression)(expr)) {
+        classBindingExpr = createClassBindingByArrayExpression(rewriteClassArrayExpression(expr, context));
+    }
+    else {
+        classBindingExpr = (0, ast_1.parseExpr)(rewriteClassExpression(classBindingProp.exp, context).content, context);
+    }
+    const staticClassPropIndex = findStaticClassIndex(props);
+    if (staticClassPropIndex > -1) {
+        const staticClass = props[staticClassPropIndex].value
+            .content;
+        if (staticClass) {
+            if (!(0, types_1.isArrayExpression)(classBindingExpr)) {
+                classBindingExpr = (0, types_1.arrayExpression)([classBindingExpr]);
+            }
+            const staticClassLiterals = parseStaticClass(staticClass);
+            if (index > staticClassPropIndex) {
+                classBindingExpr.elements.unshift(...staticClassLiterals);
+            }
+            else {
+                classBindingExpr.elements.push(...staticClassLiterals);
+            }
+        }
+    }
+    if (!context.miniProgram.class.array) {
+        classBindingExpr = parseClassBindingArrayExpr(classBindingExpr);
+    }
+    classBindingProp.exp = (0, compiler_core_1.createSimpleExpression)((0, codegen_1.genBabelExpr)(classBindingExpr));
+}
+exports.rewriteClass = rewriteClass;
+/**
+ * 目前 mp-toutiao, mp-alipay, mp-lark 不支持数组绑定class，故统一转换为字符串相加
+ * @param classBindingExpr
+ * @returns
+ */
+function parseClassBindingArrayExpr(classBindingExpr) {
+    if (!(0, types_1.isArrayExpression)(classBindingExpr)) {
+        return classBindingExpr;
+    }
+    let binaryExpr;
+    classBindingExpr.elements.forEach((expr) => {
+        if ((0, types_1.isArrayExpression)(expr)) {
+            expr = parseClassBindingArrayExpr(expr);
+        }
+        if (!binaryExpr) {
+            binaryExpr = (0, types_1.parenthesizedExpression)(expr);
+        }
+        else {
+            binaryExpr = (0, types_1.binaryExpression)('+', (0, types_1.binaryExpression)('+', binaryExpr, (0, types_1.stringLiteral)(' ')), expr);
+        }
+    });
+    return binaryExpr;
+}
+function parseStaticClass(staticClass) {
+    // 已经在 parse 阶段格式化了多余空格等
+    return staticClass.split(' ').map((clazz) => (0, types_1.stringLiteral)(clazz));
+}
+function rewriteClassExpression(expr, context) {
+    return (0, utils_1.rewriteExpression)((0, compiler_core_1.createCompoundExpression)([
+        context.helperString(runtimeHelpers_1.NORMALIZE_CLASS) + '(',
+        expr,
+        ')',
+    ]), context);
+}
+function rewriteClassArrayExpression(expr, context) {
+    expr.elements.forEach((prop, index) => {
+        if (!(0, types_1.isStringLiteral)(prop)) {
+            const code = (0, codegen_1.genBabelExpr)((0, types_1.arrayExpression)([(0, types_1.isSpreadElement)(prop) ? prop.argument : prop]));
+            expr.elements[index] = (0, types_1.identifier)(rewriteClassExpression((0, compiler_core_1.createSimpleExpression)(code.slice(1, -1), false), context).content);
+        }
+    });
+    return expr;
+}
+function rewriteClassObjectExpression(expr, loc, context) {
+    expr.properties.forEach((prop, index) => {
+        if ((0, types_1.isSpreadElement)(prop)) {
+            // <view :class="{...obj}"/>
+            // <view class="{{[a]}}"/>
+            const newExpr = (0, utils_1.rewriteSpreadElement)(runtimeHelpers_1.NORMALIZE_CLASS, prop, loc, context);
+            if (newExpr) {
+                expr.properties[index] = (0, types_1.objectProperty)(newExpr, (0, types_1.booleanLiteral)(true), true);
+            }
+        }
+        else if ((0, types_1.isObjectProperty)(prop)) {
+            const { key, value, computed } = prop;
+            if (computed) {
+                // {[handle(computedKey)]:1} => {[a]:1}
+                prop.key = (0, utils_1.parseExprWithRewrite)((0, codegen_1.genBabelExpr)(key), loc, context, key);
+            }
+            if ((0, utils_1.isStaticLiteral)(value)) {
+                return;
+            }
+            else {
+                const newExpr = (0, utils_1.parseExprWithRewriteClass)((0, codegen_1.genBabelExpr)(value), loc, context, value);
+                if (newExpr) {
+                    prop.value = newExpr;
+                }
+            }
+        }
+    });
+    return expr;
+}
+function createClassBindingByArrayExpression(expr) {
+    const elements = [];
+    expr.elements.forEach((prop) => {
+        if ((0, types_1.isStringLiteral)(prop) || (0, types_1.isIdentifier)(prop)) {
+            elements.push(prop);
+        }
+    });
+    return (0, types_1.arrayExpression)(elements);
+}
+function createClassBindingByObjectExpression(expr) {
+    const elements = [];
+    expr.properties.forEach((prop) => {
+        if ((0, types_1.isObjectProperty)(prop)) {
+            const { value } = prop;
+            if ((0, ast_1.isUndefined)(value)) {
+                // remove {a:undefined}
+                return;
+            }
+            if ((0, types_1.isLiteral)(value)) {
+                // {a:true,b:1,c:0} => ['a','b']
+                if ((0, ast_1.isTrueExpr)(value)) {
+                    elements.push(prop.computed
+                        ? prop.key
+                        : (0, ast_1.parseStringLiteral)(prop.key));
+                }
+                return;
+            }
+            elements.push((0, types_1.logicalExpression)('&&', value, prop.computed ? prop.key : (0, ast_1.parseStringLiteral)(prop.key)));
+        }
+    });
+    return (0, types_1.arrayExpression)(elements);
+}

package/dist/transforms/transformComponent.d.ts

@@ -0,0 +1,11 @@
+import { ComponentNode, DirectiveNode, ElementNode } from '@vue/compiler-core';
+import { NodeTransform, TransformContext } from '../transform';
+export declare const transformComponent: NodeTransform;
+/**
+ * 重写组件 props 绑定
+ * @param node
+ * @param context
+ */
+export declare function rewriteBinding({ tag, props }: ComponentNode, context: TransformContext): void;
+export declare function isPropsBinding({ arg }: DirectiveNode): boolean | undefined;
+export declare function rewritePropsBinding(dir: DirectiveNode, node: ElementNode, context: TransformContext): void;