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

package/dist/transforms/transformIdentifier.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformIdentifier = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const utils_1 = require("./utils");
+const transformClass_1 = require("./transformClass");
+const transformStyle_1 = require("./transformStyle");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const transformSlot_1 = require("./transformSlot");
+const vSlot_1 = require("./vSlot");
+const transformRef_1 = require("./transformRef");
+const transformComponent_1 = require("./transformComponent");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const transformIdentifier = (node, context) => {
+    return function transformIdentifier() {
+        if (node.type === 5 /* INTERPOLATION */) {
+            node.content = (0, utils_1.rewriteExpression)((0, compiler_core_1.createCompoundExpression)([
+                `${context.helperString(runtimeHelpers_1.TO_DISPLAY_STRING)}(`,
+                node.content,
+                `)`,
+            ]), context);
+        }
+        else if ((0, compiler_core_1.isSlotOutlet)(node)) {
+            (0, transformSlot_1.rewriteSlot)(node, context);
+        }
+        else if (node.type === 1 /* ELEMENT */) {
+            let hasClassBinding = false;
+            let hasStyleBinding = false;
+            (0, transformRef_1.rewriteRef)(node, context);
+            if ((0, uni_cli_shared_1.isUserComponent)(node, context)) {
+                (0, transformComponent_1.rewriteBinding)(node, context);
+            }
+            const { props } = node;
+            for (let i = 0; i < props.length; i++) {
+                const dir = props[i];
+                if (dir.type === 7 /* DIRECTIVE */) {
+                    const arg = dir.arg;
+                    if (arg) {
+                        // TODO 指令暂不不支持动态参数,v-bind:[arg] v-on:[event]
+                        if (!(arg.type === 4 /* SIMPLE_EXPRESSION */ && arg.isStatic)) {
+                            // v-slot:[slotName] 支持
+                            if (dir.name === 'slot') {
+                                (0, vSlot_1.rewriteVSlot)(dir, context);
+                            }
+                            else {
+                                props.splice(i, 1);
+                                i--;
+                                continue;
+                            }
+                        }
+                    }
+                    const exp = dir.exp;
+                    if (exp) {
+                        if (isBuiltIn(dir)) {
+                            // noop
+                        }
+                        else if ((0, transformClass_1.isClassBinding)(dir)) {
+                            hasClassBinding = true;
+                            (0, transformClass_1.rewriteClass)(i, dir, props, context);
+                        }
+                        else if ((0, transformStyle_1.isStyleBinding)(dir)) {
+                            hasStyleBinding = true;
+                            (0, transformStyle_1.rewriteStyle)(i, dir, props, context);
+                        }
+                        else if ((0, transformComponent_1.isPropsBinding)(dir)) {
+                            (0, transformComponent_1.rewritePropsBinding)(dir, node, context);
+                        }
+                        else {
+                            dir.exp = (0, utils_1.rewriteExpression)(exp, context);
+                        }
+                    }
+                }
+            }
+            if (hasClassBinding) {
+                const staticClassIndex = (0, transformClass_1.findStaticClassIndex)(props);
+                if (staticClassIndex > -1) {
+                    props.splice(staticClassIndex, 1);
+                }
+            }
+            if (hasStyleBinding) {
+                const staticStyleIndex = (0, transformStyle_1.findStaticStyleIndex)(props);
+                if (staticStyleIndex > -1) {
+                    props.splice(staticStyleIndex, 1);
+                }
+            }
+        }
+    };
+};
+exports.transformIdentifier = transformIdentifier;
+const builtInProps = [utils_1.ATTR_VUE_SLOTS];
+function isBuiltIn({ arg, exp }) {
+    return ((arg === null || arg === void 0 ? void 0 : arg.type) === 4 /* SIMPLE_EXPRESSION */ &&
+        builtInProps.includes(arg.content) &&
+        (exp === null || exp === void 0 ? void 0 : exp.type) === 4 /* SIMPLE_EXPRESSION */);
+}

package/dist/transforms/transformKey.d.ts

@@ -0,0 +1,4 @@
+import { DirectiveNode } from '@vue/compiler-core';
+import { ForElementNode } from './vFor';
+export declare function isSelfKey({ arg, exp }: DirectiveNode, vFor: ForElementNode['vFor'] | false): boolean | undefined;
+export declare function rewriteSelfKey(dir: DirectiveNode): void;

package/dist/transforms/transformKey.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteSelfKey = exports.isSelfKey = void 0;
+function isSelfKey({ arg, exp }, vFor) {
+    return (vFor &&
+        arg &&
+        exp &&
+        arg.type === 4 /* SIMPLE_EXPRESSION */ &&
+        arg.content === 'key' &&
+        exp.type === 4 /* SIMPLE_EXPRESSION */ &&
+        exp.content === vFor.valueAlias);
+}
+exports.isSelfKey = isSelfKey;
+function rewriteSelfKey(dir) {
+    ;
+    dir.exp.content = '*this';
+}
+exports.rewriteSelfKey = rewriteSelfKey;

package/dist/transforms/transformRef.d.ts

@@ -0,0 +1,3 @@
+import { ElementNode } from '@vue/compiler-core';
+import { TransformContext } from '../transform';
+export declare function rewriteRef(node: ElementNode, context: TransformContext): void;

package/dist/transforms/transformRef.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteRef = void 0;
+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 utils_1 = require("./utils");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const codegen_1 = require("../codegen");
+const ast_1 = require("../ast");
+function rewriteRef(node, context) {
+    const vueIdProp = (0, compiler_core_1.findProp)(node, utils_1.ATTR_VUE_ID);
+    if (!vueIdProp) {
+        return;
+    }
+    const refProp = (0, compiler_core_1.findProp)(node, 'u-' + uni_cli_shared_1.VUE_REF) || (0, compiler_core_1.findProp)(node, 'u-' + uni_cli_shared_1.VUE_REF_IN_FOR);
+    if (!refProp) {
+        return;
+    }
+    if ((0, compiler_core_1.findProp)(node, 'ref')) {
+        // 支付宝小程序
+        const code = parseAlipayRefCode(refProp, context);
+        if (code && context.inline && !(0, uni_cli_shared_1.isDirectiveNode)(refProp)) {
+            refProp.value.content = code;
+            const refPropIndex = node.props.findIndex((prop) => prop === refProp);
+            node.props.splice(refPropIndex, 1, (0, uni_cli_shared_1.createBindDirectiveNode)(refProp.name, code));
+        }
+    }
+    else {
+        rewriteRefProp(refProp, vueIdProp, context);
+    }
+}
+exports.rewriteRef = rewriteRef;
+function parseRef(prop, context) {
+    let expr;
+    let refKey = '';
+    const isDir = (0, uni_cli_shared_1.isDirectiveNode)(prop);
+    if (isDir) {
+        if (prop.exp) {
+            expr = (0, ast_1.parseExpr)(prop.exp, context, prop.exp);
+        }
+    }
+    else {
+        const { value } = prop;
+        if (value && value.content) {
+            if (context.inline && context.bindingMetadata[value.content]) {
+                expr = (0, types_1.identifier)(value.content);
+                refKey = value.content;
+            }
+            else {
+                expr = (0, types_1.stringLiteral)(value.content);
+            }
+        }
+    }
+    return { expr, refKey };
+}
+function parseRefCode(prop, context) {
+    const { expr, refKey } = parseRef(prop, context);
+    if (!expr) {
+        return { code: '', refKey };
+    }
+    return { code: (0, codegen_1.genBabelExpr)(expr), refKey };
+}
+function rewriteRefProp(prop, vueIdProp, context) {
+    let id = '';
+    if ((0, uni_cli_shared_1.isDirectiveNode)(vueIdProp)) {
+        const vueIdExpr = (0, ast_1.parseExpr)(vueIdProp.exp, context, vueIdProp.exp);
+        if (vueIdExpr) {
+            id = (0, codegen_1.genBabelExpr)(vueIdExpr);
+        }
+    }
+    else {
+        id = `'${vueIdProp.value.content}'`;
+    }
+    if (!id) {
+        return;
+    }
+    const { code, refKey } = parseRefCode(prop, context);
+    const opts = Object.create(null);
+    if (refKey) {
+        opts.k = refKey;
+    }
+    if (context.inVFor) {
+        opts.f = 1;
+    }
+    (0, utils_1.parseExprWithRewrite)(context.helperString(runtimeHelpers_1.SET_REF) +
+        '(' +
+        code +
+        ', ' +
+        id +
+        (Object.keys(opts).length ? ', ' + JSON.stringify(opts) : '') +
+        ')', prop.loc, context);
+}
+function parseAlipayRefCode(prop, context) {
+    var _a;
+    let expr;
+    const isDir = (0, uni_cli_shared_1.isDirectiveNode)(prop);
+    if (isDir) {
+        if (prop.exp) {
+            expr = (0, ast_1.parseExpr)(prop.exp, context, prop.exp);
+        }
+    }
+    else {
+        if ((_a = prop.value) === null || _a === void 0 ? void 0 : _a.content) {
+            expr = context.inline
+                ? processInlineRef(prop, context)
+                : (0, types_1.stringLiteral)(prop.value.content);
+        }
+    }
+    if (!expr) {
+        return;
+    }
+    return (0, codegen_1.genBabelExpr)(expr);
+}
+function processInlineRef(prop, context) {
+    const properties = [];
+    const { refKey } = parseRef(prop, context);
+    properties.push((0, types_1.objectProperty)((0, types_1.identifier)('r'), (0, types_1.identifier)(prop.value.content)));
+    if (refKey) {
+        properties.push((0, types_1.objectProperty)((0, types_1.identifier)('k'), (0, types_1.stringLiteral)(refKey)));
+    }
+    if (context.inVFor) {
+        properties.push((0, types_1.objectProperty)((0, types_1.identifier)('f'), (0, types_1.numericLiteral)(1)));
+    }
+    return (0, types_1.arrowFunctionExpression)([], (0, types_1.objectExpression)(properties));
+}

package/dist/transforms/transformRoot.d.ts

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

package/dist/transforms/transformRoot.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRoot = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const ast_1 = require("../ast");
+const types_1 = require("@babel/types");
+const codegen_1 = require("../codegen");
+const transformRoot = (node, context) => {
+    if (node.type !== 0 /* ROOT */) {
+        return;
+    }
+    if (context.bindingCssVars.length) {
+        node.children.forEach((child) => {
+            if (child.type !== 1 /* ELEMENT */) {
+                return;
+            }
+            addCssVars(child, context);
+        });
+    }
+};
+exports.transformRoot = transformRoot;
+const CSS_VARS = '__cssVars()';
+function addCssVars(node, context) {
+    var _a;
+    const styleProp = (0, compiler_core_1.findProp)(node, 'style', true);
+    if (!styleProp) {
+        node.props.push((0, uni_cli_shared_1.createBindDirectiveNode)('style', CSS_VARS));
+    }
+    else {
+        if (((_a = styleProp.exp) === null || _a === void 0 ? void 0 : _a.type) === 4 /* SIMPLE_EXPRESSION */) {
+            let expr = (0, ast_1.parseExpr)(styleProp.exp.content, context);
+            if ((0, types_1.isArrayExpression)(expr)) {
+                expr.elements.push((0, types_1.identifier)(CSS_VARS));
+            }
+            else {
+                expr = (0, types_1.arrayExpression)([expr, (0, types_1.identifier)(CSS_VARS)]);
+            }
+            styleProp.exp.content = (0, codegen_1.genBabelExpr)(expr);
+        }
+    }
+}

package/dist/transforms/transformSlot.d.ts

@@ -0,0 +1,3 @@
+import { SlotOutletNode } from '@vue/compiler-core';
+import { TransformContext } from '../transform';
+export declare function rewriteSlot(node: SlotOutletNode, context: TransformContext): void;

package/dist/transforms/transformSlot.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteSlot = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const codegen_1 = require("../codegen");
+const transform_1 = require("../transform");
+const transformElement_1 = require("./transformElement");
+const utils_1 = require("./utils");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const __1 = require("..");
+function rewriteSlot(node, context) {
+    let slotName = `"${uni_shared_1.SLOT_DEFAULT_NAME}"`;
+    let hasOtherDir = false;
+    const nonNameProps = [];
+    const { props } = node;
+    // 默认插槽强制设置name
+    if (!(0, compiler_core_1.findProp)(node, 'name')) {
+        props.unshift((0, uni_cli_shared_1.createAttributeNode)('name', 'default'));
+    }
+    for (let i = 0; i < props.length; i++) {
+        const p = props[i];
+        if (p.type === 6 /* ATTRIBUTE */) {
+            if (p.value) {
+                if (p.name === 'name') {
+                    p.value.content = (0, uni_shared_1.dynamicSlotName)(p.value.content);
+                    slotName = JSON.stringify(p.value.content);
+                }
+                else {
+                    p.name = (0, shared_1.camelize)(p.name);
+                    nonNameProps.push(p);
+                }
+            }
+        }
+        else {
+            if (p.name !== 'bind') {
+                hasOtherDir = true;
+            }
+            if (p.name === 'bind' && (0, compiler_core_1.isStaticArgOf)(p.arg, 'name')) {
+                if (p.exp) {
+                    p.exp = (0, utils_1.rewriteExpression)((0, compiler_core_1.createCompoundExpression)([
+                        context.helperString(__1.DYNAMIC_SLOT) + '(',
+                        p.exp,
+                        ')',
+                    ]), context);
+                    slotName = p.exp;
+                }
+            }
+            else {
+                if (p.name === 'bind' && p.arg && (0, compiler_core_1.isStaticExp)(p.arg)) {
+                    p.arg.content = (0, shared_1.camelize)(p.arg.content);
+                }
+                nonNameProps.push(p);
+            }
+        }
+    }
+    if (hasOtherDir) {
+        context.onError((0, compiler_core_1.createCompilerError)(36 /* X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, node.loc));
+    }
+    if (nonNameProps.length > 0) {
+        (0, transformElement_1.processProps)(node, context, nonNameProps);
+        const properties = [];
+        nonNameProps.forEach((prop) => {
+            if (prop.type === 7 /* DIRECTIVE */ && prop.name === 'bind') {
+                const property = transformProperty(prop, context);
+                property && properties.push(property);
+            }
+        });
+        if (properties.length) {
+            transformScopedSlotName(node, context);
+            const vForIndexAlias = parseVForIndexAlias(context);
+            (0, utils_1.rewriteExpression)((0, compiler_core_1.createCompoundExpression)([
+                context.helperString(runtimeHelpers_1.RENDER_SLOT) + '(',
+                slotName,
+                ',',
+                `{${properties.join(',')}}`,
+                `${vForIndexAlias ? ',' + vForIndexAlias : ''}`,
+                ')',
+            ]), context);
+        }
+        else {
+            // 非作用域默认插槽直接移除命名
+            if (slotName === `"${uni_shared_1.SLOT_DEFAULT_NAME}"`) {
+                (0, utils_1.removeAttribute)(node, 'name');
+            }
+        }
+    }
+    else {
+        // 非作用域默认插槽直接移除命名
+        if (slotName === `"${uni_shared_1.SLOT_DEFAULT_NAME}"`) {
+            (0, utils_1.removeAttribute)(node, 'name');
+        }
+    }
+}
+exports.rewriteSlot = rewriteSlot;
+function parseVForIndexAlias(context) {
+    let { currentScope } = context;
+    while (currentScope) {
+        if ((0, transform_1.isVForScope)(currentScope) && !(0, transform_1.isScopedSlotVFor)(currentScope)) {
+            return currentScope.indexAlias;
+        }
+        currentScope = currentScope.parent;
+    }
+}
+function transformScopedSlotName(node, context) {
+    if (!context.miniProgram.slot.dynamicSlotNames) {
+        return;
+    }
+    const slotKey = parseScopedSlotKey(context);
+    if (!slotKey) {
+        return;
+    }
+    const nameProps = (0, compiler_core_1.findProp)(node, 'name');
+    if (nameProps && nameProps.type === 6 /* ATTRIBUTE */ && nameProps.value) {
+        const { props } = node;
+        props.splice(props.indexOf(nameProps), 1, (0, uni_cli_shared_1.createBindDirectiveNode)('name', (0, utils_1.rewriteExpression)((0, compiler_core_1.createSimpleExpression)(`"${nameProps.value.content}-"+` + slotKey), context).content));
+    }
+}
+function parseScopedSlotKey(context) {
+    let { currentScope } = context;
+    const indexs = [];
+    while (currentScope) {
+        if ((0, transform_1.isVForScope)(currentScope)) {
+            indexs.push(currentScope.indexAlias);
+        }
+        currentScope = currentScope.parent;
+    }
+    const inFor = !!indexs.length;
+    if (inFor) {
+        return indexs.reverse().join(`+'-'+`);
+    }
+}
+function transformProperty(dir, context) {
+    if (!dir.arg || !dir.exp) {
+        return;
+    }
+    const isStaticArg = dir.arg.type === 4 /* SIMPLE_EXPRESSION */ && dir.arg.isStatic;
+    if (isStaticArg) {
+        return `${dir.arg.content}:${(0, codegen_1.genExpr)(dir.exp)}`;
+    }
+    return `[${(0, codegen_1.genExpr)(dir.arg)}||'']:${(0, codegen_1.genExpr)(dir.exp)}`;
+}

package/dist/transforms/transformStyle.d.ts

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

package/dist/transforms/transformStyle.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteStyle = exports.findStaticStyleIndex = exports.isStyleBinding = void 0;
+const types_1 = require("@babel/types");
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const ast_1 = require("../ast");
+const codegen_1 = require("../codegen");
+const utils_1 = require("./utils");
+function isStyleBinding({ arg, exp }) {
+    return (arg && arg.type === 4 /* SIMPLE_EXPRESSION */ && arg.content === 'style');
+}
+exports.isStyleBinding = isStyleBinding;
+function findStaticStyleIndex(props) {
+    return props.findIndex((prop) => prop.name === 'style');
+}
+exports.findStaticStyleIndex = findStaticStyleIndex;
+function rewriteStyle(index, styleBindingProp, props, context) {
+    if (!styleBindingProp.exp) {
+        return;
+    }
+    const expr = (0, ast_1.parseExpr)(styleBindingProp.exp, context);
+    if (!expr) {
+        return;
+    }
+    let styleBidingExpr = expr;
+    if ((0, types_1.isObjectExpression)(expr)) {
+        styleBidingExpr = createStyleBindingByObjectExpression(rewriteStyleObjectExpression(expr, styleBindingProp.loc, context));
+    }
+    else if ((0, types_1.isArrayExpression)(expr)) {
+        styleBidingExpr = createStyleBindingByArrayExpression(rewriteStyleArrayExpression(expr, context));
+    }
+    else {
+        styleBidingExpr = (0, ast_1.parseExpr)(rewriteStyleExpression(styleBindingProp.exp, context).content, context);
+    }
+    if (!styleBidingExpr) {
+        return;
+    }
+    const staticStylePropIndex = findStaticStyleIndex(props);
+    if (staticStylePropIndex > -1) {
+        const staticStyle = props[staticStylePropIndex].value
+            .content;
+        if (staticStyle.trim()) {
+            if (index > staticStylePropIndex) {
+                styleBidingExpr = (0, types_1.binaryExpression)('+', addSemicolon((0, types_1.stringLiteral)(staticStyle)), styleBidingExpr);
+            }
+            else {
+                styleBidingExpr = (0, types_1.binaryExpression)('+', addSemicolon(styleBidingExpr), (0, types_1.stringLiteral)(staticStyle));
+            }
+        }
+    }
+    styleBindingProp.exp = (0, compiler_core_1.createSimpleExpression)((0, codegen_1.genBabelExpr)(styleBidingExpr));
+}
+exports.rewriteStyle = rewriteStyle;
+function rewriteStyleExpression(expr, context) {
+    return (0, utils_1.rewriteExpression)((0, compiler_core_1.createCompoundExpression)([
+        context.helperString(runtimeHelpers_1.STRINGIFY_STYLE) + '(',
+        expr,
+        ')',
+    ]), context);
+}
+function rewriteStyleArrayExpression(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)(rewriteStyleExpression((0, compiler_core_1.createSimpleExpression)(code.slice(1, -1), false), context).content);
+        }
+    });
+    return expr;
+}
+function rewriteStyleObjectExpression(expr, loc, context) {
+    expr.properties.forEach((prop, index) => {
+        if ((0, types_1.isSpreadElement)(prop)) {
+            // <view :style="{...obj}"/>
+            // <view style="{{a}}"/>
+            const newExpr = (0, utils_1.rewriteSpreadElement)(runtimeHelpers_1.STRINGIFY_STYLE, prop, loc, context);
+            if (newExpr) {
+                prop.argument = newExpr;
+            }
+        }
+        else if ((0, types_1.isObjectProperty)(prop)) {
+            const { key, value, computed } = prop;
+            if (computed) {
+                // {[handle(computedKey)]:1} => {[a]:1}
+                const newExpr = (0, utils_1.rewirteWithHelper)(runtimeHelpers_1.HYPHENATE, key, loc, context);
+                if (newExpr) {
+                    prop.key = newExpr;
+                }
+            }
+            else {
+                // {fontSize:'15px'} => {'font-size':'15px'}
+                prop.key = (0, ast_1.parseStringLiteral)(prop.key);
+                prop.key.value = (0, shared_1.hyphenate)(prop.key.value) + ':';
+            }
+            // {fontSize:`${fontSize}px`} => {'font-size':a}
+            if ((0, utils_1.isStaticLiteral)(value)) {
+                return;
+            }
+            else {
+                const newExpr = (0, utils_1.parseExprWithRewrite)((0, codegen_1.genBabelExpr)(value), loc, context, value);
+                if (newExpr) {
+                    prop.value = newExpr;
+                }
+            }
+        }
+    });
+    return expr;
+}
+function addSemicolon(expr) {
+    return createBinaryExpression(expr, (0, types_1.stringLiteral)(';'));
+}
+function createBinaryExpression(left, right) {
+    return (0, types_1.binaryExpression)('+', left, right);
+}
+function createStyleBindingByArrayExpression(expr) {
+    let result;
+    function concat(expr) {
+        if (!result) {
+            result = expr;
+        }
+        else {
+            result = createBinaryExpression(addSemicolon(result), expr);
+        }
+    }
+    expr.elements.forEach((prop) => {
+        if ((0, types_1.isStringLiteral)(prop) || (0, types_1.isIdentifier)(prop)) {
+            concat(prop);
+        }
+    });
+    return result;
+}
+function createStyleBindingByObjectExpression(expr) {
+    let result;
+    function concat(expr) {
+        if (!result) {
+            result = expr;
+        }
+        else {
+            result = createBinaryExpression(addSemicolon(result), expr);
+        }
+    }
+    expr.properties.forEach((prop) => {
+        if ((0, types_1.isSpreadElement)(prop)) {
+            concat(prop.argument);
+        }
+        else if ((0, types_1.isObjectProperty)(prop)) {
+            const { key, value } = prop;
+            const expr = createBinaryExpression((0, types_1.isStringLiteral)(key)
+                ? key // 之前已经补充了:
+                : createBinaryExpression(key, (0, types_1.stringLiteral)(':')), value);
+            concat(expr);
+        }
+    });
+    return result;
+}

package/dist/transforms/transformTag.d.ts

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

package/dist/transforms/transformTag.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTag = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const transformTag = (node, _) => {
+    if (!(0, uni_cli_shared_1.isElementNode)(node)) {
+        return;
+    }
+    const newTag = uni_cli_shared_1.HTML_TO_MINI_PROGRAM_TAGS[node.tag];
+    if (newTag) {
+        node.tag = newTag;
+        node.tagType = 0 /* ELEMENT */;
+    }
+};
+exports.transformTag = transformTag;

package/dist/transforms/utils.d.ts

@@ -0,0 +1,25 @@
+import { Expression, Identifier, MemberExpression, SpreadElement } from '@babel/types';
+import { ElementNode, ExpressionNode, SimpleExpressionNode, SourceLocation, TransformContext as VueTransformContext } from '@vue/compiler-core';
+import { CodegenScope } from '../options';
+import { TransformContext } from '../transform';
+export declare const ATTR_VUE_ID = "u-i";
+export declare const ATTR_VUE_SLOTS = "u-s";
+export declare const ATTR_VUE_PROPS = "u-p";
+export declare const ATTR_VUE_REF: string;
+export declare const ATTR_VUE_REF_IN_FOR: string;
+export declare const ATTR_COM_TYPE = "u-t";
+export declare const SCOPED_SLOT_IDENTIFIER = "__SCOPED_SLOT__";
+export declare function rewriteSpreadElement(name: symbol, expr: SpreadElement, loc: SourceLocation, context: TransformContext): Identifier | MemberExpression | undefined;
+export declare function rewirteWithHelper(name: symbol, expr: Expression, loc: SourceLocation, context: TransformContext): Identifier | MemberExpression | undefined;
+export declare function parseExprWithRewrite(code: string, loc: SourceLocation, context: TransformContext, node?: Expression): Identifier | MemberExpression | undefined;
+export declare function parseExprWithRewriteClass(code: string, loc: SourceLocation, context: TransformContext, node: Expression): Identifier | MemberExpression | undefined;
+export declare function rewriteExpressionWithoutProperty(node: ExpressionNode, context: TransformContext, babelNode?: Expression, scope?: CodegenScope): SimpleExpressionNode;
+export declare function rewriteExpression(node: ExpressionNode, context: TransformContext | VueTransformContext, babelNode?: Expression, scope?: CodegenScope, { property, ignoreLiteral, referencedScope, }?: {
+    property: boolean;
+    ignoreLiteral: boolean;
+    referencedScope?: CodegenScope;
+}): SimpleExpressionNode;
+export declare function findReferencedScope(node: Expression, scope: CodegenScope): CodegenScope;
+export declare function isReferencedByIds(node: Expression, knownIds: string[]): boolean;
+export declare function isStaticLiteral(value: object | null | undefined): boolean;
+export declare function removeAttribute(node: ElementNode, name: string): void;