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

package/dist/transforms/vSlot.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVSlotCallExpression = exports.rewriteScopedSlotVForScope = exports.findCurrentPath = exports.findSlotName = exports.rewriteVSlot = exports.transformSlot = void 0;
+const types_1 = require("@babel/types");
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const ast_1 = require("../ast");
+const codegen_1 = require("../codegen");
+const transform_1 = require("../transform");
+const utils_1 = require("./utils");
+const vFor_1 = require("./vFor");
+const runtimeHelpers_2 = require("../runtimeHelpers");
+const transformSlot = (node, context) => {
+    if (!(0, uni_cli_shared_1.isUserComponent)(node, context)) {
+        return;
+    }
+    const { tag, children } = node;
+    const slots = new Set();
+    const onComponentSlot = (0, compiler_core_1.findDir)(node, 'slot', true);
+    const implicitDefaultChildren = [];
+    const isMiniProgramComponent = context.isMiniProgramComponent(tag);
+    for (let i = 0; i < children.length; i++) {
+        const slotElement = children[i];
+        let slotDir;
+        if (!(0, compiler_core_1.isTemplateNode)(slotElement) ||
+            !(slotDir = (0, compiler_core_1.findDir)(slotElement, 'slot', true))) {
+            // not a <template v-slot>, skip.
+            if (slotElement.type !== 3 /* COMMENT */) {
+                implicitDefaultChildren.push(slotElement);
+            }
+            continue;
+        }
+        if (onComponentSlot) {
+            // already has on-component slot - this is incorrect usage.
+            context.onError((0, compiler_core_1.createCompilerError)(37 /* X_V_SLOT_MIXED_SLOT_USAGE */, slotDir.loc));
+            break;
+        }
+        if (!slotDir.arg) {
+            // v-slot => v-slot:default
+            slotDir.arg = (0, compiler_core_1.createSimpleExpression)('default', true);
+        }
+        const slotName = transformTemplateSlotElement(slotDir, slotElement, node, context);
+        // 小程序组件默认插槽，直接移除<template #default>节点
+        if (isMiniProgramComponent) {
+            if (slotName === 'default' && slotElement.children.length === 1) {
+                children.splice(i, 1, slotElement.children[0]);
+            }
+            continue;
+        }
+        if (slotName) {
+            slots.add(slotName);
+        }
+    }
+    if (isMiniProgramComponent) {
+        return;
+    }
+    if (implicitDefaultChildren.length) {
+        slots.add(uni_shared_1.SLOT_DEFAULT_NAME);
+    }
+    if (onComponentSlot) {
+        // <unicloud-db v-slot:default="{data, loading, error, options}"/>
+        // => <unicloud-db collection=""><template v-slot:default="{data, loading, error, options}"/></unicloud-db>
+        slots.add(uni_shared_1.SLOT_DEFAULT_NAME);
+        const templateNode = createTemplateNode(onComponentSlot, implicitDefaultChildren);
+        transformTemplateSlotElement(onComponentSlot, templateNode, node, context);
+        node.children = [templateNode];
+    }
+    // 不支持 $slots, 则自动补充 props
+    if (slots.size && !context.miniProgram.slot.$slots) {
+        const slotsArr = [...slots];
+        const hasDynamic = slotsArr.find((name) => !(0, shared_1.isString)(name));
+        let value;
+        if (hasDynamic) {
+            const children = [];
+            const len = slotsArr.length - 1;
+            slotsArr.forEach((name, index) => {
+                if ((0, shared_1.isString)(name)) {
+                    children.push(`'${(0, uni_shared_1.dynamicSlotName)(name)}'`);
+                }
+                else {
+                    children.push(name);
+                }
+                if (index < len) {
+                    children.push(',');
+                }
+            });
+            value = (0, compiler_core_1.createCompoundExpression)([
+                context.helperString(runtimeHelpers_2.DYNAMIC_SLOT) + '([',
+                ...children,
+                '])',
+            ]);
+        }
+        else {
+            value = `[${slotsArr
+                .map((name) => `'${(0, uni_shared_1.dynamicSlotName)(name)}'`)
+                .join(',')}]`;
+        }
+        node.props.unshift((0, uni_cli_shared_1.createBindDirectiveNode)(utils_1.ATTR_VUE_SLOTS, value));
+    }
+};
+exports.transformSlot = transformSlot;
+function rewriteVSlot(dir, context) {
+    dir.arg = (0, utils_1.rewriteExpression)((0, compiler_core_1.createCompoundExpression)([
+        context.helperString(runtimeHelpers_2.DYNAMIC_SLOT) + '(',
+        dir.arg,
+        ')',
+    ]), context);
+}
+exports.rewriteVSlot = rewriteVSlot;
+function transformTemplateSlotElement(slotDir, slotTemplate, slotComponent, context) {
+    const slotName = findSlotName(slotDir);
+    if (!slotName) {
+        return;
+    }
+    const { exp } = slotDir;
+    // non scoped slots
+    if (!exp) {
+        return slotName;
+    }
+    // empty
+    if (exp.type === 4 /* SIMPLE_EXPRESSION */ && !exp.content.trim()) {
+        return slotName;
+    }
+    // 使用vFor来简单处理scoped slot作用域问题
+    slotTemplate.children = [
+        createVForTemplate(slotTemplate, { name: slotName, value: (0, codegen_1.genExpr)(exp), slotComponent }, context),
+    ];
+    if (context.miniProgram.slot.dynamicSlotNames) {
+        // 已经在 vFor 中补充 slot，故需要移除 slotTemplate 中的
+        const index = slotTemplate.props.indexOf(slotDir);
+        if (index > -1) {
+            slotTemplate.props.splice(index, 1);
+        }
+    }
+    // v-slot="slotProps" => v-slot 避免 transformIdentifier 生成 slotProps 的变量声明
+    slotDir.exp = undefined;
+    return slotName;
+}
+function createTemplateNode(slotDir, children) {
+    return {
+        type: 1 /* ELEMENT */,
+        tag: 'template',
+        tagType: 3 /* TEMPLATE */,
+        loc: compiler_core_1.locStub,
+        isSelfClosing: false,
+        codegenNode: undefined,
+        ns: 0,
+        props: [slotDir],
+        children,
+    };
+}
+function findSlotName(slotDir) {
+    if (!slotDir.arg) {
+        return uni_shared_1.SLOT_DEFAULT_NAME;
+    }
+    if ((0, compiler_core_1.isStaticExp)(slotDir.arg)) {
+        return slotDir.arg.content;
+    }
+    return slotDir.arg;
+}
+exports.findSlotName = findSlotName;
+function findCurrentVForValueAlias(context) {
+    let scope = context.currentScope;
+    while (scope) {
+        if ((0, transform_1.isVForScope)(scope)) {
+            return scope.valueAlias;
+        }
+        scope = scope.parent;
+    }
+    return '';
+}
+function createVForTemplate(slotElement, { name, value, slotComponent, }, context) {
+    const slotName = 's' + context.scopes.vFor;
+    const keyProp = (0, uni_cli_shared_1.createBindDirectiveNode)('key', 'i' + context.scopes.vFor);
+    const source = (0, shared_1.isString)(name) ? `'${name}'` : (0, codegen_1.genExpr)(name);
+    const vForProp = {
+        type: 7 /* DIRECTIVE */,
+        name: 'for',
+        loc: compiler_core_1.locStub,
+        modifiers: [],
+        arg: undefined,
+        exp: (0, compiler_core_1.createSimpleExpression)(`(${value}, ${slotName}) in ${utils_1.SCOPED_SLOT_IDENTIFIER}(${source}, ${findCurrentVForValueAlias(context) || `''`})`),
+    };
+    const props = [vForProp, keyProp];
+    if (context.miniProgram.slot.dynamicSlotNames) {
+        props.push((0, uni_cli_shared_1.createBindDirectiveNode)('slot', slotName));
+    }
+    return {
+        loc: slotElement.loc,
+        ns: 0,
+        tag: 'template',
+        type: 1 /* ELEMENT */,
+        tagType: 3 /* TEMPLATE */,
+        props,
+        isSelfClosing: false,
+        codegenNode: undefined,
+        children: slotElement.children,
+        slotComponent,
+    };
+}
+const slotNameRE = /\('(.*)',/;
+/**
+ * ('default','') => default
+ * @param source
+ * @returns
+ */
+function findCurrentSlotName(source) {
+    return (0, types_1.stringLiteral)((0, uni_shared_1.dynamicSlotName)(source.children[1].match(slotNameRE)[1]));
+}
+function createPathBinaryExpr(scope, computed = true) {
+    return (0, types_1.binaryExpression)('+', (0, types_1.binaryExpression)('+', (0, types_1.stringLiteral)(parseVForPath(scope.sourceAlias) + (computed ? '[' : '.')), (0, types_1.identifier)(scope.indexAlias)), (0, types_1.stringLiteral)(computed ? '].' : '.'));
+}
+function findCurrentPath(id, scope) {
+    let parent = scope.parent;
+    let binaryExpr = null;
+    while (parent) {
+        if ((0, transform_1.isVForScope)(parent)) {
+            // const computed = !isScopedSlotVFor(parent)
+            if (!binaryExpr) {
+                binaryExpr = createPathBinaryExpr(parent);
+            }
+            else {
+                binaryExpr = (0, types_1.binaryExpression)('+', createPathBinaryExpr(parent), binaryExpr);
+            }
+        }
+        parent = parent.parent;
+    }
+    return ((binaryExpr && (0, types_1.binaryExpression)('+', binaryExpr, (0, types_1.stringLiteral)(id))) ||
+        (0, types_1.stringLiteral)(id));
+}
+exports.findCurrentPath = findCurrentPath;
+function findCurrentVueIdExpr(node, context) {
+    if (!node) {
+        return (0, types_1.stringLiteral)('');
+    }
+    const vueIdProp = (0, compiler_core_1.findProp)(node, utils_1.ATTR_VUE_ID);
+    if (vueIdProp.type === 6 /* ATTRIBUTE */) {
+        return (0, types_1.stringLiteral)(vueIdProp.value.content);
+    }
+    return (0, ast_1.parseExpr)((0, codegen_1.genExpr)(vueIdProp.exp), context) || (0, types_1.stringLiteral)('');
+}
+/**
+ * 目前无用
+ * @param vForScope
+ * @param parentScope
+ * @param context
+ */
+function rewriteScopedSlotVForScope(vForScope, parentScope, context) {
+    // 生成一个新的sourceAlias，用于scopedSlots
+    const { source, sourceExpr } = vForScope;
+    vForScope.sourceAlias = (0, utils_1.rewriteExpressionWithoutProperty)(source, context, sourceExpr, parentScope).content;
+}
+exports.rewriteScopedSlotVForScope = rewriteScopedSlotVForScope;
+function parseVForPath(id) {
+    return id.includes('.') ? id.split('.')[1] : id;
+}
+function createVSlotCallExpression(slotComponent, vForScope, context) {
+    const { source, sourceAlias } = vForScope;
+    const id = parseVForPath(sourceAlias);
+    return (0, types_1.callExpression)((0, types_1.identifier)(context.helperString(runtimeHelpers_1.WITH_SCOPED_SLOT)), [
+        (0, vFor_1.createVForArrowFunctionExpression)(vForScope),
+        (0, types_1.objectExpression)([
+            // 插槽名称，数据更新 path，vueId
+            (0, types_1.objectProperty)((0, types_1.identifier)('name'), findCurrentSlotName(source)),
+            // 暂不生成 path
+            (0, types_1.objectProperty)((0, types_1.identifier)('path'), findCurrentPath(id, vForScope)),
+            (0, types_1.objectProperty)((0, types_1.identifier)('vueId'), findCurrentVueIdExpr(slotComponent, context)),
+        ]),
+    ]);
+}
+exports.createVSlotCallExpression = createVSlotCallExpression;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dcloudio/uni-mp-compiler",
+  "version": "0.0.1-nvue3.3030820220125001",
+  "description": "uni-mp-compiler",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-mp-compiler"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "license": "Apache-2.0",
+  "gitHead": "33e807d66e1fe47e2ee08ad9c59247e37b8884da",
+  "dependencies": {
+    "@babel/generator": "^7.16.0",
+    "@babel/parser": "^7.16.4",
+    "@babel/types": "^7.16.0",
+    "@dcloudio/uni-cli-shared": "0.0.1-nvue3.3030820220125001",
+    "@dcloudio/uni-shared": "0.0.1-nvue3.3030820220125001",
+    "@vue/compiler-core": "3.2.29",
+    "@vue/compiler-dom": "3.2.29",
+    "@vue/shared": "3.2.29",
+    "estree-walker": "^2.0.2"
+  },
+  "devDependencies": {
+    "@vue/compiler-sfc": "3.2.29",
+    "source-map": "^0.6.1"
+  }
+}