@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/vue/transforms/templateTransformAssetUrl.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAssetUrl = exports.createAssetUrlTransformWithOptions = exports.normalizeOptions = exports.defaultAssetUrlOptions = void 0;
+const path_1 = __importDefault(require("path"));
+const compiler_core_1 = require("@vue/compiler-core");
+const templateUtils_1 = require("./templateUtils");
+const shared_1 = require("@vue/shared");
+exports.defaultAssetUrlOptions = {
+    base: null,
+    includeAbsolute: false,
+    tags: {
+        video: ['src', 'poster'],
+        source: ['src'],
+        img: ['src'],
+        image: ['xlink:href', 'href'],
+        use: ['xlink:href', 'href'],
+    },
+};
+const normalizeOptions = (options) => {
+    if (Object.keys(options).some((key) => (0, shared_1.isArray)(options[key]))) {
+        // legacy option format which directly passes in tags config
+        return {
+            ...exports.defaultAssetUrlOptions,
+            tags: options,
+        };
+    }
+    return {
+        ...exports.defaultAssetUrlOptions,
+        ...options,
+    };
+};
+exports.normalizeOptions = normalizeOptions;
+const createAssetUrlTransformWithOptions = (options) => {
+    return (node, context) => exports.transformAssetUrl(node, context, options);
+};
+exports.createAssetUrlTransformWithOptions = createAssetUrlTransformWithOptions;
+/**
+ * A `@vue/compiler-core` plugin that transforms relative asset urls into
+ * either imports or absolute urls.
+ *
+ * ``` js
+ * // Before
+ * createVNode('img', { src: './logo.png' })
+ *
+ * // After
+ * import _imports_0 from './logo.png'
+ * createVNode('img', { src: _imports_0 })
+ * ```
+ */
+const transformAssetUrl = (node, context, options = exports.defaultAssetUrlOptions) => {
+    if (node.type === 1 /* ELEMENT */) {
+        if (!node.props.length) {
+            return;
+        }
+        const tags = options.tags || exports.defaultAssetUrlOptions.tags;
+        const attrs = tags[node.tag];
+        const wildCardAttrs = tags['*'];
+        if (!attrs && !wildCardAttrs) {
+            return;
+        }
+        // 策略：
+        // h5 平台保留原始策略
+        // 非 h5 平台
+        // - 绝对路径 static 资源不做转换
+        // - 相对路径 static 资源转换为绝对路径
+        // - 非 static 资源转换为 import
+        const assetAttrs = (attrs || []).concat(wildCardAttrs || []);
+        node.props.forEach((attr, index) => {
+            if (attr.type !== 6 /* ATTRIBUTE */ ||
+                !assetAttrs.includes(attr.name) ||
+                !attr.value ||
+                (0, templateUtils_1.isExternalUrl)(attr.value.content) ||
+                (0, templateUtils_1.isDataUrl)(attr.value.content) ||
+                attr.value.content[0] === '#') {
+                return;
+            }
+            // fixed by xxxxxx 区分 static 资源
+            const isStaticAsset = attr.value.content.indexOf('/static/') > -1;
+            // 绝对路径的静态资源不作处理
+            if (isStaticAsset && !(0, templateUtils_1.isRelativeUrl)(attr.value.content)) {
+                return;
+            }
+            const url = (0, templateUtils_1.parseUrl)(attr.value.content);
+            if (options.base && attr.value.content[0] === '.' && isStaticAsset) {
+                // explicit base - directly rewrite relative urls into absolute url
+                // to avoid generating extra imports
+                // Allow for full hostnames provided in options.base
+                const base = (0, templateUtils_1.parseUrl)(options.base);
+                const protocol = base.protocol || '';
+                const host = base.host ? protocol + '//' + base.host : '';
+                const basePath = base.path || '/';
+                // when packaged in the browser, path will be using the posix-
+                // only version provided by rollup-plugin-node-builtins.
+                attr.value.content =
+                    host +
+                        (path_1.default.posix || path_1.default).join(basePath, url.path + (url.hash || ''));
+                return;
+            }
+            // otherwise, transform the url into an import.
+            // this assumes a bundler will resolve the import into the correct
+            // absolute url (e.g. webpack file-loader)
+            const exp = getImportsExpressionExp(url.path, url.hash, attr.loc, context);
+            node.props[index] = {
+                type: 7 /* DIRECTIVE */,
+                name: 'bind',
+                arg: (0, compiler_core_1.createSimpleExpression)(attr.name, true, attr.loc),
+                exp,
+                modifiers: [],
+                loc: attr.loc,
+            };
+        });
+    }
+};
+exports.transformAssetUrl = transformAssetUrl;
+function getImportsExpressionExp(path, hash, loc, context) {
+    if (path) {
+        let name;
+        let exp;
+        const existingIndex = context.imports.findIndex((i) => i.path === path);
+        if (existingIndex > -1) {
+            name = `_imports_${existingIndex}`;
+            exp = context.imports[existingIndex].exp;
+        }
+        else {
+            name = `_imports_${context.imports.length}`;
+            exp = (0, compiler_core_1.createSimpleExpression)(name, false, loc, 2 /* CAN_HOIST */);
+            context.imports.push({ exp, path });
+        }
+        if (!hash) {
+            return exp;
+        }
+        const hashExp = `${name} + '${hash}'`;
+        const existingHoistIndex = context.hoists.findIndex((h) => {
+            return (h &&
+                h.type === 4 /* SIMPLE_EXPRESSION */ &&
+                !h.isStatic &&
+                h.content === hashExp);
+        });
+        if (existingHoistIndex > -1) {
+            return (0, compiler_core_1.createSimpleExpression)(`_hoisted_${existingHoistIndex + 1}`, false, loc, 2 /* CAN_HOIST */);
+        }
+        return context.hoist((0, compiler_core_1.createSimpleExpression)(hashExp, false, loc, 2 /* CAN_HOIST */));
+    }
+    else {
+        return (0, compiler_core_1.createSimpleExpression)(`''`, false, loc, 2 /* CAN_HOIST */);
+    }
+}

package/dist/vue/transforms/templateTransformSrcset.d.ts

@@ -0,0 +1,4 @@
+import { NodeTransform } from '@vue/compiler-core';
+import { AssetURLOptions } from './templateTransformAssetUrl';
+export declare const createSrcsetTransformWithOptions: (options: Required<AssetURLOptions>) => NodeTransform;
+export declare const transformSrcset: NodeTransform;

package/dist/vue/transforms/templateTransformSrcset.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSrcset = exports.createSrcsetTransformWithOptions = void 0;
+const path_1 = __importDefault(require("path"));
+const compiler_core_1 = require("@vue/compiler-core");
+const templateUtils_1 = require("./templateUtils");
+const templateTransformAssetUrl_1 = require("./templateTransformAssetUrl");
+const srcsetTags = ['img', 'source'];
+// http://w3c.github.io/html/semantics-embedded-content.html#ref-for-image-candidate-string-5
+const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
+const createSrcsetTransformWithOptions = (options) => {
+    return (node, context) => exports.transformSrcset(node, context, options);
+};
+exports.createSrcsetTransformWithOptions = createSrcsetTransformWithOptions;
+const transformSrcset = (node, context, options = templateTransformAssetUrl_1.defaultAssetUrlOptions) => {
+    if (node.type === 1 /* ELEMENT */) {
+        if (srcsetTags.includes(node.tag) && node.props.length) {
+            node.props.forEach((attr, index) => {
+                if (attr.name === 'srcset' && attr.type === 6 /* ATTRIBUTE */) {
+                    if (!attr.value)
+                        return;
+                    const value = attr.value.content;
+                    if (!value)
+                        return;
+                    const imageCandidates = value
+                        .split(',')
+                        .map((s) => {
+                        // The attribute value arrives here with all whitespace, except
+                        // normal spaces, represented by escape sequences
+                        const [url, descriptor] = s
+                            .replace(escapedSpaceCharacters, ' ')
+                            .trim()
+                            .split(' ', 2);
+                        return { url, descriptor };
+                    });
+                    // data urls contains comma after the ecoding so we need to re-merge
+                    // them
+                    for (let i = 0; i < imageCandidates.length; i++) {
+                        const { url } = imageCandidates[i];
+                        if ((0, templateUtils_1.isDataUrl)(url)) {
+                            imageCandidates[i + 1].url =
+                                url + ',' + imageCandidates[i + 1].url;
+                            imageCandidates.splice(i, 1);
+                        }
+                    }
+                    const hasQualifiedUrl = imageCandidates.some(({ url }) => {
+                        return (!(0, templateUtils_1.isExternalUrl)(url) &&
+                            !(0, templateUtils_1.isDataUrl)(url) &&
+                            (options.includeAbsolute || (0, templateUtils_1.isRelativeUrl)(url)));
+                    });
+                    // When srcset does not contain any qualified URLs, skip transforming
+                    if (!hasQualifiedUrl) {
+                        return;
+                    }
+                    if (options.base) {
+                        const base = options.base;
+                        const set = [];
+                        imageCandidates.forEach(({ url, descriptor }) => {
+                            descriptor = descriptor ? ` ${descriptor}` : ``;
+                            if ((0, templateUtils_1.isRelativeUrl)(url)) {
+                                set.push((path_1.default.posix || path_1.default).join(base, url) + descriptor);
+                            }
+                            else {
+                                set.push(url + descriptor);
+                            }
+                        });
+                        attr.value.content = set.join(', ');
+                        return;
+                    }
+                    const compoundExpression = (0, compiler_core_1.createCompoundExpression)([], attr.loc);
+                    imageCandidates.forEach(({ url, descriptor }, index) => {
+                        if (!(0, templateUtils_1.isExternalUrl)(url) &&
+                            !(0, templateUtils_1.isDataUrl)(url) &&
+                            (options.includeAbsolute || (0, templateUtils_1.isRelativeUrl)(url))) {
+                            const { path } = (0, templateUtils_1.parseUrl)(url);
+                            let exp;
+                            if (path) {
+                                const existingImportsIndex = context.imports.findIndex((i) => i.path === path);
+                                if (existingImportsIndex > -1) {
+                                    exp = (0, compiler_core_1.createSimpleExpression)(`_imports_${existingImportsIndex}`, false, attr.loc, 2 /* CAN_HOIST */);
+                                }
+                                else {
+                                    exp = (0, compiler_core_1.createSimpleExpression)(`_imports_${context.imports.length}`, false, attr.loc, 2 /* CAN_HOIST */);
+                                    context.imports.push({ exp, path });
+                                }
+                                compoundExpression.children.push(exp);
+                            }
+                        }
+                        else {
+                            const exp = (0, compiler_core_1.createSimpleExpression)(`"${url}"`, false, attr.loc, 2 /* CAN_HOIST */);
+                            compoundExpression.children.push(exp);
+                        }
+                        const isNotLast = imageCandidates.length - 1 > index;
+                        if (descriptor && isNotLast) {
+                            compoundExpression.children.push(` + ' ${descriptor}, ' + `);
+                        }
+                        else if (descriptor) {
+                            compoundExpression.children.push(` + ' ${descriptor}'`);
+                        }
+                        else if (isNotLast) {
+                            compoundExpression.children.push(` + ', ' + `);
+                        }
+                    });
+                    const hoisted = context.hoist(compoundExpression);
+                    hoisted.constType = 2 /* CAN_HOIST */;
+                    node.props[index] = {
+                        type: 7 /* DIRECTIVE */,
+                        name: 'bind',
+                        arg: (0, compiler_core_1.createSimpleExpression)('srcset', true, attr.loc),
+                        exp: hoisted,
+                        modifiers: [],
+                        loc: attr.loc,
+                    };
+                }
+            });
+        }
+    }
+};
+exports.transformSrcset = transformSrcset;

package/dist/vue/transforms/templateUtils.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { UrlWithStringQuery } from 'url';
+export declare function isRelativeUrl(url: string): boolean;
+export declare function isExternalUrl(url: string): boolean;
+export declare function isDataUrl(url: string): boolean;
+/**
+ * Parses string url into URL object.
+ */
+export declare function parseUrl(url: string): UrlWithStringQuery;

package/dist/vue/transforms/templateUtils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUrl = exports.isDataUrl = exports.isExternalUrl = exports.isRelativeUrl = void 0;
+const url_1 = require("url");
+const shared_1 = require("@vue/shared");
+function isRelativeUrl(url) {
+    const firstChar = url.charAt(0);
+    return firstChar === '.' || firstChar === '~' || firstChar === '@';
+}
+exports.isRelativeUrl = isRelativeUrl;
+const externalRE = /^(https?:)?\/\//;
+function isExternalUrl(url) {
+    return externalRE.test(url);
+}
+exports.isExternalUrl = isExternalUrl;
+const dataUrlRE = /^\s*data:/i;
+function isDataUrl(url) {
+    return dataUrlRE.test(url);
+}
+exports.isDataUrl = isDataUrl;
+/**
+ * Parses string url into URL object.
+ */
+function parseUrl(url) {
+    const firstChar = url.charAt(0);
+    if (firstChar === '~') {
+        const secondChar = url.charAt(1);
+        url = url.slice(secondChar === '/' ? 2 : 1);
+    }
+    return parseUriParts(url);
+}
+exports.parseUrl = parseUrl;
+/**
+ * vuejs/component-compiler-utils#22 Support uri fragment in transformed require
+ * @param urlString an url as a string
+ */
+function parseUriParts(urlString) {
+    // A TypeError is thrown if urlString is not a string
+    // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
+    return (0, url_1.parse)((0, shared_1.isString)(urlString) ? urlString : '', false, true);
+}

package/dist/vue/transforms/transformComponent.d.ts

@@ -0,0 +1,3 @@
+import { NodeTypes, RootNode, TemplateChildNode, TransformContext } from '@vue/compiler-core';
+import { COMPONENT_BIND_LINK, COMPONENT_ON_LINK } from '../../mp/constants';
+export declare function createTransformComponentLink(name: typeof COMPONENT_BIND_LINK | typeof COMPONENT_ON_LINK, type?: NodeTypes.ATTRIBUTE | NodeTypes.DIRECTIVE): (node: RootNode | TemplateChildNode, context: TransformContext) => void;

package/dist/vue/transforms/transformComponent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformComponentLink = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const utils_1 = require("../utils");
+function createTransformComponentLink(name, type = 7 /* DIRECTIVE */) {
+    return function transformComponentLink(node, context) {
+        if (!(0, utils_1.isUserComponent)(node, context)) {
+            return;
+        }
+        if (type === 7 /* DIRECTIVE */) {
+            node.props.push({
+                type: 7 /* DIRECTIVE */,
+                name: 'on',
+                modifiers: [],
+                loc: compiler_core_1.locStub,
+                arg: (0, compiler_core_1.createSimpleExpression)(name, true),
+                exp: (0, compiler_core_1.createSimpleExpression)('__l', true),
+            });
+        }
+        else {
+            node.props.push((0, utils_1.createAttributeNode)(name, '__l'));
+        }
+    };
+}
+exports.createTransformComponentLink = createTransformComponentLink;

package/dist/vue/transforms/transformEvent.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveNode, ElementNode, NodeTransform } from '@vue/compiler-core';
+export declare function createTransformEvent(options: Record<string, string | ((node: ElementNode, dir: DirectiveNode) => string)>): NodeTransform;

package/dist/vue/transforms/transformEvent.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformEvent = void 0;
+const shared_1 = require("@vue/shared");
+const ast_1 = require("../../vite/utils/ast");
+function createTransformEvent(options) {
+    return function transformEvent(node) {
+        if (!(0, ast_1.isElementNode)(node)) {
+            return;
+        }
+        node.props.forEach((prop) => {
+            const { name, arg } = prop;
+            if (name === 'on' && arg && (0, ast_1.isSimpleExpressionNode)(arg)) {
+                const eventType = options[arg.content];
+                if (eventType) {
+                    // e.g tap => click
+                    if ((0, shared_1.isFunction)(eventType)) {
+                        arg.content = eventType(node, prop);
+                    }
+                    else {
+                        arg.content = eventType;
+                    }
+                }
+            }
+        });
+    };
+}
+exports.createTransformEvent = createTransformEvent;

package/dist/vue/transforms/transformPageHead.d.ts

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

package/dist/vue/transforms/transformPageHead.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPageHead = void 0;
+const utils_1 = require("../../utils");
+const transformPageHead = (node, context) => {
+    // 发现是page-meta下的head,直接remove该节点
+    (0, utils_1.checkElementNodeTag)(node, 'head') &&
+        (0, utils_1.checkElementNodeTag)(context.parent, 'page-meta') &&
+        context.removeNode(node);
+};
+exports.transformPageHead = transformPageHead;

package/dist/vue/transforms/transformRef.d.ts

@@ -0,0 +1,2 @@
+import { RootNode, TemplateChildNode, TransformContext } from '@vue/compiler-core';
+export declare function transformRef(node: RootNode | TemplateChildNode, context: TransformContext): void;

package/dist/vue/transforms/transformRef.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRef = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const utils_1 = require("../utils");
+function transformRef(node, context) {
+    if (!(0, utils_1.isUserComponent)(node, context)) {
+        return;
+    }
+    addVueRef(node, context);
+}
+exports.transformRef = transformRef;
+function addVueRef(node, context) {
+    // 仅配置了 ref 属性的，才需要增补 vue-ref
+    const refProp = (0, compiler_core_1.findProp)(node, 'ref');
+    if (!refProp) {
+        return;
+    }
+    if (refProp.type === 6 /* ATTRIBUTE */) {
+        refProp.name = 'u-' + utils_1.VUE_REF;
+    }
+    else {
+        ;
+        refProp.arg.content = 'u-' + utils_1.VUE_REF;
+    }
+    return (0, utils_1.addStaticClass)(node, 
+    // ref-in-for
+    // ref
+    context.inVFor
+        ? utils_1.VUE_REF_IN_FOR
+        : utils_1.VUE_REF);
+}

package/dist/vue/transforms/transformTag.d.ts

@@ -0,0 +1,2 @@
+import { NodeTransform } from '@vue/compiler-core';
+export declare function createTransformTag(opts: Record<string, string>): NodeTransform;

package/dist/vue/transforms/transformTag.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformTag = void 0;
+const ast_1 = require("../../vite/utils/ast");
+function createTransformTag(opts) {
+    return function transformTag(node, context) {
+        if (!(0, ast_1.isElementNode)(node)) {
+            return;
+        }
+        const oldTag = node.tag;
+        const newTag = opts[oldTag];
+        if (!newTag) {
+            return;
+        }
+        node.tag = newTag;
+    };
+}
+exports.createTransformTag = createTransformTag;

package/dist/vue/transforms/vModel.d.ts

@@ -0,0 +1,12 @@
+import { DirectiveTransform, ElementNode, TransformContext } from '@vue/compiler-core';
+export declare function defaultMatch(node: ElementNode, context: TransformContext): boolean;
+interface CreateTransformModelOptions {
+    match: typeof defaultMatch;
+}
+/**
+ * 百度、快手小程序的自定义组件，不支持动态事件绑定，故 v-model 也需要调整
+ * @param baseTransformModel
+ * @returns
+ */
+export declare function createTransformModel(baseTransformModel: DirectiveTransform, { match }?: CreateTransformModelOptions): DirectiveTransform;
+export {};

package/dist/vue/transforms/vModel.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformModel = exports.defaultMatch = void 0;
+const utils_1 = require("../utils");
+const vOn_1 = require("./vOn");
+function defaultMatch(node, context) {
+    return (0, utils_1.isUserComponent)(node, context);
+}
+exports.defaultMatch = defaultMatch;
+/**
+ * 百度、快手小程序的自定义组件，不支持动态事件绑定，故 v-model 也需要调整
+ * @param baseTransformModel
+ * @returns
+ */
+function createTransformModel(baseTransformModel, { match } = {
+    match: defaultMatch,
+}) {
+    return (dir, node, context, augmentor) => {
+        const res = baseTransformModel(dir, node, context, augmentor);
+        if (!match(node, context)) {
+            return res;
+        }
+        const props = res.props;
+        if (props[1]) {
+            // input,textarea 的 v-model 事件可能会被合并到已有的 input 中
+            const { arg, exp } = props[1];
+            (0, vOn_1.addEventOpts)(arg.content, exp, node);
+            props[1].exp = (0, vOn_1.createCustomEventExpr)();
+        }
+        return res;
+    };
+}
+exports.createTransformModel = createTransformModel;

package/dist/vue/transforms/vOn.d.ts

@@ -0,0 +1,15 @@
+import { ExpressionNode, DirectiveTransform, ElementNode, TransformContext } from '@vue/compiler-core';
+export declare function defaultMatch(name: string, node: ElementNode, context: TransformContext): boolean;
+interface CreateTransformOnOptions {
+    match: typeof defaultMatch;
+}
+/**
+ * 百度、快手小程序的自定义组件，不支持动态事件绑定，故转换为静态事件 + dataset
+ * @param baseTransformOn
+ * @returns
+ */
+export declare function createTransformOn(baseTransformOn: DirectiveTransform, { match }?: CreateTransformOnOptions): DirectiveTransform;
+export declare function createCustomEventExpr(): import("@vue/compiler-core").SimpleExpressionNode;
+export declare function addEventOpts(event: string, value: ExpressionNode, node: ElementNode): void;
+export declare const ATTR_DATASET_EVENT_OPTS = "data-e-o";
+export {};

package/dist/vue/transforms/vOn.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTR_DATASET_EVENT_OPTS = exports.addEventOpts = exports.createCustomEventExpr = exports.createTransformOn = exports.defaultMatch = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const utils_1 = require("../utils");
+function defaultMatch(name, node, context) {
+    return isCustomEvent(name) && (0, utils_1.isUserComponent)(node, context);
+}
+exports.defaultMatch = defaultMatch;
+/**
+ * 百度、快手小程序的自定义组件，不支持动态事件绑定，故转换为静态事件 + dataset
+ * @param baseTransformOn
+ * @returns
+ */
+function createTransformOn(baseTransformOn, { match } = {
+    match: defaultMatch,
+}) {
+    return (dir, node, context, augmentor) => {
+        const res = baseTransformOn(dir, node, context, augmentor);
+        const { name, arg, exp } = dir;
+        if (name !== 'on' || !arg || !exp || !(0, compiler_core_1.isStaticExp)(arg)) {
+            return res;
+        }
+        if (!match(arg.content, node, context)) {
+            return res;
+        }
+        const value = res.props[0].value;
+        res.props[0].value = createCustomEventExpr();
+        addEventOpts(arg.content, value, node);
+        return res;
+    };
+}
+exports.createTransformOn = createTransformOn;
+function createCustomEventExpr() {
+    return (0, compiler_core_1.createSimpleExpression)('__e', true);
+}
+exports.createCustomEventExpr = createCustomEventExpr;
+function addEventOpts(event, value, node) {
+    const attrName = node.tagType === 1 /* COMPONENT */
+        ? ATTR_DATA_EVENT_OPTS
+        : exports.ATTR_DATASET_EVENT_OPTS;
+    const opts = (0, compiler_core_1.findProp)(node, attrName, true);
+    if (!opts) {
+        node.props.push(createDataEventOptsProp(attrName, event, value));
+    }
+    else {
+        const children = opts.exp.children;
+        children.splice(children.length - 2, 0, createDataEventOptsProperty(event, value));
+    }
+}
+exports.addEventOpts = addEventOpts;
+const ATTR_DATA_EVENT_OPTS = 'eO';
+exports.ATTR_DATASET_EVENT_OPTS = 'data-e-o';
+function createDataEventOptsProperty(event, exp) {
+    return (0, compiler_core_1.createCompoundExpression)([`'${event}'`, ': ', exp, ',']);
+}
+function createDataEventOptsProp(name, event, exp) {
+    return {
+        type: 7 /* DIRECTIVE */,
+        name: 'bind',
+        loc: compiler_core_1.locStub,
+        modifiers: [],
+        arg: (0, compiler_core_1.createSimpleExpression)(name, true),
+        exp: (0, compiler_core_1.createCompoundExpression)([
+            '{',
+            createDataEventOptsProperty(event, exp),
+            '}',
+        ]),
+    };
+}
+const builtInEvents = [
+    '__l',
+    'tap',
+    'longtap',
+    'longpress',
+    'touchstart',
+    'touchmove',
+    'touchcancel',
+    'touchend',
+    'touchforcechange',
+    'transitionend',
+    'animationstart',
+    'animationiteration',
+    'animationend',
+];
+function isCustomEvent(name) {
+    return !builtInEvents.includes(name);
+}

package/dist/vue/utils.d.ts

@@ -0,0 +1,31 @@
+import { AttributeNode, ComponentNode, DirectiveNode, ElementNode, RootNode, ExpressionNode, TemplateChildNode, TransformContext } from '@vue/compiler-core';
+export declare const VUE_REF = "r";
+export declare const VUE_REF_IN_FOR = "r-i-f";
+export declare function isVueSfcFile(id: string): boolean;
+export declare function isUserComponent(node: RootNode | TemplateChildNode, context: {
+    isBuiltInComponent: TransformContext['isBuiltInComponent'];
+}): node is ComponentNode;
+export declare function createAttributeNode(name: string, content: string): AttributeNode;
+export declare function addStaticClass(node: ElementNode, clazz: string): string | number | undefined;
+export declare function createDirectiveNode(name: string, arg: string, exp?: string | ExpressionNode): DirectiveNode;
+export declare function createOnDirectiveNode(name: string, value: string): DirectiveNode;
+export declare function createBindDirectiveNode(name: string, value: string | ExpressionNode): DirectiveNode;
+export declare function createUniVueTransformAssetUrls(base: string): {
+    base: string;
+    includeAbsolute: boolean;
+    tags: {
+        audio: string[];
+        video: string[];
+        img: string[];
+        image: string[];
+        'cover-image': string[];
+        'v-uni-audio': string[];
+        'v-uni-video': string[];
+        'v-uni-image': string[];
+        'v-uni-cover-image': string[];
+        'u-image': string[];
+        'u-video': string[];
+    };
+};
+export declare function getBaseNodeTransforms(base: string): import("@vue/compiler-core").NodeTransform[];
+export declare function renameProp(name: string, prop?: DirectiveNode | AttributeNode): void;