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

package/dist/transforms/vIf.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIf = exports.transformIf = exports.isIfElementNode = void 0;
+const types_1 = require("@babel/types");
+const compiler_core_1 = require("@vue/compiler-core");
+const ast_1 = require("../ast");
+const transform_1 = require("../transform");
+const transformExpression_1 = require("./transformExpression");
+const utils_1 = require("./utils");
+function isIfElementNode(node) {
+    return !!node.vIf;
+}
+exports.isIfElementNode = isIfElementNode;
+exports.transformIf = (0, transform_1.createStructuralDirectiveTransform)(/^(if|else|else-if)$/, (node, dir, context) => {
+    return processIf(node, dir, context, (ifNode, branch, isRoot) => {
+        const { currentScope: parentScope, popScope } = context;
+        const ifOptions = {
+            name: dir.name,
+        };
+        branch.vIf = ifOptions;
+        const condition = dir.exp ? (0, ast_1.parseExpr)(dir.exp, context) : undefined;
+        const vIfScope = context.addVIfScope({
+            name: dir.name,
+            condition,
+        });
+        if (condition) {
+            if (!(0, utils_1.isStaticLiteral)(condition)) {
+                ifOptions.condition = (0, utils_1.rewriteExpression)(dir.exp, context, condition, parentScope).content;
+            }
+            else {
+                ifOptions.condition = dir.exp.content;
+            }
+        }
+        return () => {
+            if (isRoot) {
+                parentScope.properties.push((0, ast_1.createVIfSpreadElement)(vIfScope));
+            }
+            else {
+                const vIfSpreadElement = findVIfSpreadElement(parentScope);
+                if (!vIfSpreadElement) {
+                    popScope();
+                    return context.onError((0, compiler_core_1.createCompilerError)(30 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc));
+                }
+                let alternate = (0, ast_1.createObjectExpression)([]);
+                if (dir.name === 'else-if') {
+                    alternate = (0, ast_1.createVIfConditionalExpression)(vIfScope);
+                }
+                else if (dir.name === 'else') {
+                    alternate = (0, ast_1.createObjectExpression)(vIfScope.properties);
+                }
+                findVIfConditionalExpression(vIfSpreadElement.argument).alternate = alternate;
+            }
+            popScope();
+        };
+    });
+});
+function processIf(node, dir, context, processCodegen) {
+    if (dir.name !== 'else' &&
+        (!dir.exp || !dir.exp.content.trim())) {
+        const loc = dir.exp ? dir.exp.loc : node.loc;
+        context.onError((0, compiler_core_1.createCompilerError)(28 /* X_V_IF_NO_EXPRESSION */, dir.loc));
+        dir.exp = (0, compiler_core_1.createSimpleExpression)(`true`, false, loc);
+    }
+    if (context.prefixIdentifiers && dir.exp) {
+        // dir.exp can only be simple expression because vIf transform is applied
+        // before expression transform.
+        dir.exp = (0, transformExpression_1.processExpression)(dir.exp, context);
+    }
+    if (dir.name === 'if') {
+        const ifNode = {
+            type: 9 /* IF */,
+            loc: node.loc,
+            branches: [node],
+        };
+        context.replaceNode(ifNode);
+        if (processCodegen) {
+            return processCodegen(ifNode, node, true);
+        }
+    }
+    else {
+        // locate the adjacent v-if
+        const siblings = context.parent.children;
+        let i = siblings.indexOf(node);
+        while (i-- >= -1) {
+            const sibling = siblings[i];
+            if (sibling && sibling.type === 3 /* COMMENT */) {
+                context.removeNode(sibling);
+                continue;
+            }
+            if (sibling &&
+                sibling.type === 2 /* TEXT */ &&
+                !sibling.content.trim().length) {
+                context.removeNode(sibling);
+                continue;
+            }
+            if (sibling && sibling.type === 9 /* IF */) {
+                // Check if v-else was followed by v-else-if
+                if (dir.name === 'else-if' &&
+                    sibling.branches[sibling.branches.length - 1].vIf.condition === undefined) {
+                    context.onError((0, compiler_core_1.createCompilerError)(30 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc));
+                }
+                // move the node to the if node's branches
+                context.removeNode();
+                sibling.branches.push(node);
+                const onExit = processCodegen &&
+                    processCodegen(sibling, node, false);
+                // since the branch was removed, it will not be traversed.
+                // make sure to traverse here.
+                (0, transform_1.traverseNode)(node, context);
+                // call on exit
+                if (onExit)
+                    onExit();
+                // make sure to reset currentNode after traversal to indicate this
+                // node has been removed.
+                context.currentNode = null;
+            }
+            else {
+                context.onError((0, compiler_core_1.createCompilerError)(30 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc));
+            }
+            break;
+        }
+    }
+}
+exports.processIf = processIf;
+function findVIfSpreadElement({ properties }) {
+    const len = properties.length;
+    for (let i = len - 1; i >= 0; i--) {
+        const prop = properties[i];
+        if ((0, types_1.isSpreadElement)(prop)) {
+            return prop;
+        }
+    }
+}
+function findVIfConditionalExpression(vIfConditionalExpression) {
+    if ((0, types_1.isConditionalExpression)(vIfConditionalExpression.alternate)) {
+        return findVIfConditionalExpression(vIfConditionalExpression.alternate);
+    }
+    return vIfConditionalExpression;
+}

package/dist/transforms/vModel.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveTransform } from '@vue/compiler-core';
+export declare const transformModel: DirectiveTransform;

package/dist/transforms/vModel.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformModel = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const compiler_dom_1 = require("@vue/compiler-dom");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const codegen_1 = require("../codegen");
+const vOn_1 = require("./vOn");
+const transformModel = (dir, node, _context) => {
+    const context = _context;
+    const baseResult = (0, compiler_core_1.transformModel)(dir, node, _context);
+    // base transform has errors OR component v-model (only need props)
+    if (!baseResult.props.length || node.tagType === 1 /* COMPONENT */) {
+        return transformComponentVModel(baseResult.props, node, context);
+    }
+    if (dir.arg) {
+        context.onError((0, compiler_dom_1.createDOMCompilerError)(55 /* X_V_MODEL_ARG_ON_ELEMENT */, dir.arg.loc));
+    }
+    function checkDuplicatedValue() {
+        const value = (0, compiler_core_1.findProp)(node, 'value');
+        if (value) {
+            context.onError((0, compiler_dom_1.createDOMCompilerError)(57 /* X_V_MODEL_UNNECESSARY_VALUE */, value.loc));
+        }
+    }
+    const { tag } = node;
+    if (tag === 'input' || tag === 'textarea') {
+        checkDuplicatedValue();
+    }
+    else {
+        context.onError((0, compiler_dom_1.createDOMCompilerError)(54 /* X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc));
+    }
+    return transformElementVModel(baseResult.props, node, context);
+};
+exports.transformModel = transformModel;
+function findInputDirectiveNode(props) {
+    return props.find((prop) => {
+        var _a;
+        return prop.type === 7 /* DIRECTIVE */ &&
+            prop.name === 'on' &&
+            ((_a = prop.arg) === null || _a === void 0 ? void 0 : _a.type) === 4 /* SIMPLE_EXPRESSION */ &&
+            prop.arg.content === 'input';
+    });
+}
+function transformElementVModel(props, node, context) {
+    const dirs = transformVModel(props, node, context, {
+        binding: 'value',
+        event: 'input',
+        formatEventCode(code) {
+            return code.replace(`= $event`, `= $event.detail.value`);
+        },
+    });
+    if (dirs.length === 2) {
+        // 快手小程序的 input v-model 被转换到 data-e-o 中，补充到 data-e-o 中
+        const inputExp = findDatasetEventOpts(node);
+        if (inputExp) {
+            inputExp.children[2] = combineVOn(dirs[1].exp, inputExp.children[2], node, context);
+            dirs.length = 1;
+        }
+        else {
+            const inputDir = findInputDirectiveNode(node.props);
+            if (inputDir && inputDir.exp) {
+                // 合并到已有的 input 事件中
+                inputDir.exp = combineVOn(dirs[1].exp, inputDir.exp, node, context);
+                dirs.length = 1;
+            }
+        }
+    }
+    return { props: dirs };
+}
+/**
+ * {
+ *  "type": 7,
+ *  "name": "bind",
+ *  "loc": {},
+ *  "modifiers": [],
+ *  "arg": {
+ *    "type": 4,
+ *    "loc": {},
+ *    "content": "data-e-o",
+ *    "isStatic": true,
+ *    "constType": 3
+ *  },
+ * "exp": {
+ *  "type": 8,
+ *  "loc": {},
+ *  "children": ["{", {
+ *   "type": 8,
+ *   "loc": {},
+ *   "children": ["'input'", ": ", {
+ *    "type": 8,
+ *    "loc": {},
+ *    "children": ["_o(", {
+ *     "type": 4,
+ *     "content": "_ctx.input",
+ *     "isStatic": false,
+ *     "constType": 0,
+ *     "loc": {}
+ *    }, ")"]
+ *   }, ","]
+ *  }, "}"]
+ * }
+ * }
+ * @param node
+ * @returns
+ */
+function findDatasetEventOpts(node) {
+    const eventOptsProp = (0, compiler_core_1.findProp)(node, uni_cli_shared_1.ATTR_DATASET_EVENT_OPTS, true, false);
+    if (!eventOptsProp) {
+        return;
+    }
+    const { exp } = eventOptsProp;
+    if ((exp === null || exp === void 0 ? void 0 : exp.type) !== 8 /* COMPOUND_EXPRESSION */) {
+        return;
+    }
+    for (let i = 0; i < exp.children.length; i++) {
+        const childExp = exp.children[i];
+        if ((0, shared_1.isSymbol)(childExp) || (0, shared_1.isString)(childExp)) {
+            continue;
+        }
+        if (childExp.type !== 8 /* COMPOUND_EXPRESSION */) {
+            continue;
+        }
+        if (childExp.children[0] !== `'input'`) {
+            continue;
+        }
+        const inputExp = childExp.children[2];
+        if ((0, shared_1.isSymbol)(inputExp) ||
+            (0, shared_1.isString)(inputExp) ||
+            inputExp.type !== 8 /* COMPOUND_EXPRESSION */) {
+            continue;
+        }
+        return childExp;
+    }
+}
+function parseVOn(exp, context) {
+    return (0, codegen_1.genExpr)(exp).slice(context.helperString(runtimeHelpers_1.V_ON).length + 1, -1);
+}
+function combineVOn(exp1, exp2, node, context) {
+    return (0, vOn_1.wrapperVOn)((0, compiler_core_1.createCompoundExpression)([
+        `[`,
+        parseVOn(exp1, context),
+        ',',
+        parseVOn(exp2, context),
+        `]`,
+    ]), node, context);
+}
+function transformComponentVModel(props, node, context) {
+    return {
+        props: transformVModel(props, node, context, {
+            formatEventCode(code) {
+                return code;
+            },
+        }),
+    };
+}
+function transformVModel(props, node, context, { binding, event, formatEventCode, }) {
+    if (props.length !== 2) {
+        return [];
+    }
+    const { key: modelValueArg, value: modelValeExpr } = props[0];
+    const { key: onUpdateArg, value: onUpdateExpr } = props[1];
+    if (modelValueArg.type !== 4 /* SIMPLE_EXPRESSION */) {
+        return [];
+    }
+    if (onUpdateArg.type !== 4 /* SIMPLE_EXPRESSION */ ||
+        !onUpdateArg.content.startsWith('onUpdate:')) {
+        return [];
+    }
+    const vBindModelValue = (0, uni_cli_shared_1.createBindDirectiveNode)(binding || modelValueArg.content, (0, codegen_1.genExpr)(modelValeExpr));
+    const vOnUpdate = (0, uni_cli_shared_1.createOnDirectiveNode)(event || (0, shared_1.camelize)(onUpdateArg.content.replace('onUpdate:', 'update-')), formatEventCode((0, codegen_1.genExpr)((0, vOn_1.wrapperVOn)(
+    // onUpdateExpr 通常是 ExpressionNode 或者被 cache 的 ExpressionNode
+    (onUpdateExpr.type === 20 /* JS_CACHE_EXPRESSION */
+        ? onUpdateExpr.value
+        : onUpdateExpr), node, context))));
+    return [vBindModelValue, vOnUpdate];
+}

package/dist/transforms/vOn.d.ts

@@ -0,0 +1,8 @@
+import { DirectiveNode, ExpressionNode, SimpleExpressionNode, DirectiveTransform, ElementNode } from '@vue/compiler-core';
+import { TransformContext } from '../transform';
+export interface VOnDirectiveNode extends DirectiveNode {
+    arg: ExpressionNode;
+    exp: SimpleExpressionNode | undefined;
+}
+export declare const transformOn: DirectiveTransform;
+export declare function wrapperVOn(value: ExpressionNode, node: ElementNode, context: TransformContext): ExpressionNode;

package/dist/transforms/vOn.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapperVOn = exports.transformOn = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const __1 = require("..");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const transformExpression_1 = require("./transformExpression");
+const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+const transformOn = (dir, node, _context, augmentor) => {
+    const context = _context;
+    const { loc, modifiers, arg } = dir;
+    if (!dir.exp && !modifiers.length) {
+        context.onError((0, compiler_core_1.createCompilerError)(35 /* X_V_ON_NO_EXPRESSION */, loc));
+    }
+    let eventName;
+    if (arg.type === 4 /* SIMPLE_EXPRESSION */) {
+        if (arg.isStatic) {
+            const rawName = arg.content;
+            // for all event listeners, auto convert it to camelCase. See issue #2249
+            eventName = (0, compiler_core_1.createSimpleExpression)((0, shared_1.toHandlerKey)((0, shared_1.camelize)(rawName)), true, arg.loc);
+        }
+        else {
+            // #2388
+            eventName = (0, compiler_core_1.createCompoundExpression)([
+                // `${context.helperString(TO_HANDLER_KEY)}(`,
+                arg,
+                // `)`,
+            ]);
+        }
+    }
+    else {
+        // already a compound expression.
+        eventName = arg;
+        eventName.children.unshift(`${context.helperString(compiler_core_1.TO_HANDLER_KEY)}(`);
+        eventName.children.push(`)`);
+    }
+    // handler processing
+    let exp = dir.exp;
+    if (exp && !exp.content.trim()) {
+        exp = undefined;
+    }
+    let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
+    if (exp) {
+        const isMemberExp = (0, compiler_core_1.isMemberExpression)(exp.content, context);
+        const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
+        const hasMultipleStatements = exp.content.includes(`;`);
+        // process the expression since it's been skipped
+        if (context.prefixIdentifiers) {
+            isInlineStatement && context.addIdentifiers(`$event`);
+            exp = dir.exp = (0, transformExpression_1.processExpression)(exp, context, false, hasMultipleStatements);
+            isInlineStatement && context.removeIdentifiers(`$event`);
+            // with scope analysis, the function is hoistable if it has no reference
+            // to scope variables.
+            shouldCache =
+                context.cacheHandlers &&
+                    // unnecessary to cache inside v-once
+                    !context.inVOnce &&
+                    // runtime constants don't need to be cached
+                    // (this is analyzed by compileScript in SFC <script setup>)
+                    !(exp.type === 4 /* SIMPLE_EXPRESSION */ && exp.constType > 0) &&
+                    // #1541 bail if this is a member exp handler passed to a component -
+                    // we need to use the original function to preserve arity,
+                    // e.g. <transition> relies on checking cb.length to determine
+                    // transition end handling. Inline function is ok since its arity
+                    // is preserved even when cached.
+                    !(isMemberExp && node.tagType === 1 /* COMPONENT */) &&
+                    // bail if the function references closure variables (v-for, v-slot)
+                    // it must be passed fresh to avoid stale values.
+                    !(0, compiler_core_1.hasScopeRef)(exp, context.identifiers) &&
+                    // wxs event
+                    !isFilterExpr(exp, context);
+            // If the expression is optimizable and is a member expression pointing
+            // to a function, turn it into invocation (and wrap in an arrow function
+            // below) so that it always accesses the latest value when called - thus
+            // avoiding the need to be patched.
+            if (shouldCache && isMemberExp) {
+                if (exp.type === 4 /* SIMPLE_EXPRESSION */) {
+                    exp.content = `${exp.content} && ${exp.content}(...args)`;
+                }
+                else {
+                    exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];
+                }
+            }
+        }
+        if (isInlineStatement || (shouldCache && isMemberExp)) {
+            // wrap inline statement in a function expression
+            exp = (0, compiler_core_1.createCompoundExpression)([
+                `${isInlineStatement
+                    ? context.isTS
+                        ? `($event: any)`
+                        : `$event`
+                    : `${context.isTS ? `\n//@ts-ignore\n` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
+                exp,
+                hasMultipleStatements ? `}` : `)`,
+            ]);
+        }
+    }
+    let ret = {
+        props: [
+            (0, compiler_core_1.createObjectProperty)(eventName, exp || (0, compiler_core_1.createSimpleExpression)(`() => {}`, false, loc)),
+        ],
+    };
+    // apply extended compiler augmentor
+    if (augmentor) {
+        ret = augmentor(ret);
+    }
+    // TODO
+    if (shouldCache) {
+        // cache handlers so that it's always the same handler being passed down.
+        // this avoids unnecessary re-renders when users use inline handlers on
+        // components.
+        // ret.props[0].value = wrapper(
+        //   context.cache(ret.props[0].value) as ExpressionNode,
+        //   context
+        // )
+        ret.props[0].value = wrapperVOn(ret.props[0].value, node, context);
+    }
+    else {
+        ret.props[0].value = wrapperVOn(ret.props[0].value, node, context);
+    }
+    // mark the key as handler for props normalization check
+    ret.props.forEach((p) => (p.key.isHandlerKey = true));
+    return ret;
+};
+exports.transformOn = transformOn;
+function isFilterExpr(value, context) {
+    if (context.filters.length && value.type === 8 /* COMPOUND_EXPRESSION */) {
+        const firstChild = value.children[0];
+        if (firstChild.type === 4 /* SIMPLE_EXPRESSION */ &&
+            context.filters.includes(firstChild.content)) {
+            return true;
+        }
+    }
+    return false;
+}
+function wrapperVOn(value, node, context) {
+    var _a;
+    if ((0, transformExpression_1.isBuiltInIdentifier)(value)) {
+        return value;
+    }
+    // wxs event
+    if (isFilterExpr(value, context)) {
+        return value;
+    }
+    const keys = [];
+    if (((_a = context.miniProgram.event) === null || _a === void 0 ? void 0 : _a.key) && context.inVFor) {
+        const keyProp = (0, compiler_core_1.findProp)(node, 'key');
+        // 仅对 v-for 中 item.id 类型做处理，使用索引无需处理，避免引发更多问题
+        if (keyProp && (0, uni_cli_shared_1.isDirectiveNode)(keyProp) && keyProp.exp) {
+            const keyCode = (0, __1.genExpr)(keyProp.exp);
+            if (keyCode && keyCode.includes('.')) {
+                keys.push(',');
+                keys.push((0, __1.genExpr)(keyProp.exp));
+            }
+        }
+    }
+    return (0, compiler_core_1.createCompoundExpression)([
+        `${context.helperString(runtimeHelpers_1.V_ON)}(`,
+        value,
+        ...keys,
+        `)`,
+    ]);
+}
+exports.wrapperVOn = wrapperVOn;

package/dist/transforms/vSlot.d.ts

@@ -0,0 +1,16 @@
+import { BinaryExpression } from '@babel/types';
+import { ComponentNode, CompoundExpressionNode, DirectiveNode } from '@vue/compiler-core';
+import { CodegenScope, CodegenVForScope } from '../options';
+import { NodeTransform, TransformContext } from '../transform';
+export declare const transformSlot: NodeTransform;
+export declare function rewriteVSlot(dir: DirectiveNode, context: TransformContext): void;
+export declare function findSlotName(slotDir: DirectiveNode): string | CompoundExpressionNode;
+export declare function findCurrentPath(id: string, scope: CodegenScope): BinaryExpression | import("@babel/types").StringLiteral;
+/**
+ * 目前无用
+ * @param vForScope
+ * @param parentScope
+ * @param context
+ */
+export declare function rewriteScopedSlotVForScope(vForScope: CodegenVForScope, parentScope: CodegenScope, context: TransformContext): void;
+export declare function createVSlotCallExpression(slotComponent: ComponentNode, vForScope: CodegenVForScope, context: TransformContext): import("@babel/types").CallExpression;