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

package/dist/vite/plugins/vitejs/server/moduleGraph.d.ts

@@ -0,0 +1 @@
+export type { ModuleNode } from 'vite';

package/dist/vite/plugins/vitejs/server/moduleGraph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vite/plugins/vitejs/utils.d.ts

@@ -0,0 +1,29 @@
+export declare function slash(p: string): string;
+export declare const bareImportRE: RegExp;
+export declare const deepImportRE: RegExp;
+export declare const isWindows: boolean;
+export declare function normalizePath(id: string): string;
+export declare const queryRE: RegExp;
+export declare const hashRE: RegExp;
+export declare const cleanUrl: (url: string) => string;
+export declare const externalRE: RegExp;
+export declare const isExternalUrl: (url: string) => boolean;
+export declare const dataUrlRE: RegExp;
+export declare const isDataUrl: (url: string) => boolean;
+export declare function asyncReplace(input: string, re: RegExp, replacer: (match: RegExpExecArray) => string | Promise<string>): Promise<string>;
+export declare function isObject(value: unknown): value is Record<string, any>;
+export declare function pad(source: string, n?: number): string;
+export declare function posToNumber(source: string, pos: number | {
+    line: number;
+    column: number;
+}): number;
+export declare function generateCodeFrame(source: string, start?: number | {
+    line: number;
+    column: number;
+}, end?: number): string;
+interface ImageCandidate {
+    url: string;
+    descriptor: string;
+}
+export declare function processSrcSet(srcs: string, replacer: (arg: ImageCandidate) => Promise<string>): Promise<string>;
+export {};

package/dist/vite/plugins/vitejs/utils.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSrcSet = exports.generateCodeFrame = exports.posToNumber = exports.pad = exports.isObject = exports.asyncReplace = exports.isDataUrl = exports.dataUrlRE = exports.isExternalUrl = exports.externalRE = exports.cleanUrl = exports.hashRE = exports.queryRE = exports.normalizePath = exports.isWindows = exports.deepImportRE = exports.bareImportRE = exports.slash = void 0;
+/**
+ * https://github.com/vitejs/vite/blob/main/packages/vite/src/node/utils.ts
+ */
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function slash(p) {
+    return p.replace(/\\/g, '/');
+}
+exports.slash = slash;
+exports.bareImportRE = /^[\w@](?!.*:\/\/)/;
+exports.deepImportRE = /^([^@][^/]*)\/|^(@[^/]+\/[^/]+)\//;
+exports.isWindows = os_1.default.platform() === 'win32';
+function normalizePath(id) {
+    return path_1.default.posix.normalize(exports.isWindows ? slash(id) : id);
+}
+exports.normalizePath = normalizePath;
+exports.queryRE = /\?.*$/s;
+exports.hashRE = /#.*$/s;
+const cleanUrl = (url) => url.replace(exports.hashRE, '').replace(exports.queryRE, '');
+exports.cleanUrl = cleanUrl;
+exports.externalRE = /^(https?:)?\/\//;
+const isExternalUrl = (url) => exports.externalRE.test(url);
+exports.isExternalUrl = isExternalUrl;
+exports.dataUrlRE = /^\s*data:/i;
+const isDataUrl = (url) => exports.dataUrlRE.test(url);
+exports.isDataUrl = isDataUrl;
+async function asyncReplace(input, re, replacer) {
+    let match;
+    let remaining = input;
+    let rewritten = '';
+    while ((match = re.exec(remaining))) {
+        rewritten += remaining.slice(0, match.index);
+        rewritten += await replacer(match);
+        remaining = remaining.slice(match.index + match[0].length);
+    }
+    rewritten += remaining;
+    return rewritten;
+}
+exports.asyncReplace = asyncReplace;
+function isObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+exports.isObject = isObject;
+const splitRE = /\r?\n/;
+const range = 2;
+function pad(source, n = 2) {
+    const lines = source.split(splitRE);
+    return lines.map((l) => ` `.repeat(n) + l).join(`\n`);
+}
+exports.pad = pad;
+function posToNumber(source, pos) {
+    if (typeof pos === 'number')
+        return pos;
+    const lines = source.split(splitRE);
+    const { line, column } = pos;
+    let start = 0;
+    for (let i = 0; i < line - 1; i++) {
+        start += lines[i].length + 1;
+    }
+    return start + column;
+}
+exports.posToNumber = posToNumber;
+function generateCodeFrame(source, start = 0, end) {
+    start = posToNumber(source, start);
+    end = end || start;
+    const lines = source.split(splitRE);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+exports.generateCodeFrame = generateCodeFrame;
+const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
+async function processSrcSet(srcs, replacer) {
+    const imageCandidates = srcs
+        .split(',')
+        .map((s) => {
+        const [url, descriptor] = s
+            .replace(escapedSpaceCharacters, ' ')
+            .trim()
+            .split(' ', 2);
+        return { url, descriptor };
+    })
+        .filter(({ url }) => !!url);
+    const ret = await Promise.all(imageCandidates.map(async ({ url, descriptor }) => {
+        return {
+            url: await replacer({ url, descriptor }),
+            descriptor,
+        };
+    }));
+    const url = ret.reduce((prev, { url, descriptor }, index) => {
+        descriptor = descriptor || '';
+        return (prev +=
+            url + ` ${descriptor}${index === ret.length - 1 ? '' : ', '}`);
+    }, '');
+    return url;
+}
+exports.processSrcSet = processSrcSet;

package/dist/vite/utils/ast.d.ts

@@ -0,0 +1,17 @@
+import type { Literal, BaseNode, Property, Identifier, CallExpression, AssignmentExpression, MemberExpression, MethodDefinition, ExportSpecifier } from 'estree';
+import { Node, ElementNode, DirectiveNode, SimpleExpressionNode } from '@vue/compiler-core';
+export declare const isProperty: (node: BaseNode) => node is Property;
+export declare const isIdentifier: (node: BaseNode) => node is Identifier;
+export declare const isAssignmentExpression: (node: BaseNode) => node is AssignmentExpression;
+export declare const isCallExpression: (node: BaseNode) => node is CallExpression;
+export declare const isMemberExpression: (node: BaseNode) => node is MemberExpression;
+export declare const isMethodDefinition: (node: BaseNode) => node is MethodDefinition;
+export declare const isExportSpecifier: (node: BaseNode) => node is ExportSpecifier;
+export declare const isReference: (node: BaseNode, parent: BaseNode) => boolean;
+export declare function createLiteral(value: string): Literal;
+export declare function createIdentifier(name: string): Identifier;
+export declare function createCallExpression(callee: unknown, args: unknown[]): CallExpression;
+export declare function parseVue(code: string, errors: SyntaxError[]): import("@vue/compiler-core").RootNode;
+export declare function isElementNode(node: Node): node is ElementNode;
+export declare function isDirectiveNode(node: Node): node is DirectiveNode;
+export declare function isSimpleExpressionNode(node: Node): node is SimpleExpressionNode;

package/dist/vite/utils/ast.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSimpleExpressionNode = exports.isDirectiveNode = exports.isElementNode = exports.parseVue = exports.createCallExpression = exports.createIdentifier = exports.createLiteral = exports.isReference = exports.isExportSpecifier = exports.isMethodDefinition = exports.isMemberExpression = exports.isCallExpression = exports.isAssignmentExpression = exports.isIdentifier = exports.isProperty = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const isProperty = (node) => node.type === 'Property';
+exports.isProperty = isProperty;
+const isIdentifier = (node) => node.type === 'Identifier';
+exports.isIdentifier = isIdentifier;
+const isAssignmentExpression = (node) => node.type === 'AssignmentExpression';
+exports.isAssignmentExpression = isAssignmentExpression;
+const isCallExpression = (node) => node.type === 'CallExpression';
+exports.isCallExpression = isCallExpression;
+const isMemberExpression = (node) => node.type === 'MemberExpression';
+exports.isMemberExpression = isMemberExpression;
+const isMethodDefinition = (node) => node.type === 'MethodDefinition';
+exports.isMethodDefinition = isMethodDefinition;
+const isExportSpecifier = (node) => node.type === 'ExportSpecifier';
+exports.isExportSpecifier = isExportSpecifier;
+const isReference = (node, parent) => {
+    if ((0, exports.isMemberExpression)(node)) {
+        return !node.computed && (0, exports.isReference)(node.object, node);
+    }
+    if ((0, exports.isIdentifier)(node)) {
+        if ((0, exports.isMemberExpression)(parent))
+            return parent.computed || node === parent.object;
+        // `bar` in { bar: foo }
+        if ((0, exports.isProperty)(parent) && node !== parent.value)
+            return false;
+        // `bar` in `class Foo { bar () {...} }`
+        if ((0, exports.isMethodDefinition)(parent))
+            return false;
+        // `bar` in `export { foo as bar }`
+        if ((0, exports.isExportSpecifier)(parent) && node !== parent.local)
+            return false;
+        return true;
+    }
+    return false;
+};
+exports.isReference = isReference;
+function createLiteral(value) {
+    return {
+        type: 'Literal',
+        value,
+        raw: `'${value}'`,
+    };
+}
+exports.createLiteral = createLiteral;
+function createIdentifier(name) {
+    return {
+        type: 'Identifier',
+        name,
+    };
+}
+exports.createIdentifier = createIdentifier;
+function createCallExpression(callee, args) {
+    return {
+        type: 'CallExpression',
+        callee,
+        arguments: args,
+    };
+}
+exports.createCallExpression = createCallExpression;
+function parseVue(code, errors) {
+    return (0, compiler_dom_1.parse)(code, {
+        isNativeTag: () => true,
+        isPreTag: () => true,
+        getTextMode: () => 0 /* DATA */,
+        onError: (e) => {
+            errors.push(e);
+        },
+    });
+}
+exports.parseVue = parseVue;
+function isElementNode(node) {
+    return node.type === 1 /* ELEMENT */;
+}
+exports.isElementNode = isElementNode;
+function isDirectiveNode(node) {
+    return node.type === 7 /* DIRECTIVE */;
+}
+exports.isDirectiveNode = isDirectiveNode;
+function isSimpleExpressionNode(node) {
+    return node.type === 4 /* SIMPLE_EXPRESSION */;
+}
+exports.isSimpleExpressionNode = isSimpleExpressionNode;

package/dist/vite/utils/index.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedConfig } from 'vite';
+export * from './ast';
+export * from './url';
+export * from './plugin';
+export * from './utils';
+export declare const buildInCssSet: Set<string>;
+export declare function isCombineBuiltInCss(config: ResolvedConfig): boolean;

package/dist/vite/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCombineBuiltInCss = exports.buildInCssSet = void 0;
+__exportStar(require("./ast"), exports);
+__exportStar(require("./url"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./utils"), exports);
+// 内置组件css列表，h5平台需要合并进去首页css中
+exports.buildInCssSet = new Set();
+function isCombineBuiltInCss(config) {
+    return config.command === 'build' && config.build.cssCodeSplit;
+}
+exports.isCombineBuiltInCss = isCombineBuiltInCss;

package/dist/vite/utils/plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin, ResolvedConfig } from 'vite';
+export declare type CreateUniViteFilterPlugin = (opts: UniViteFilterPluginOptions) => Plugin;
+export interface UniViteFilterPluginOptions {
+    resolvedConfig: ResolvedConfig;
+    filter: (id: string) => boolean;
+}
+export declare function injectAssetPlugin(config: ResolvedConfig): void;
+export declare function injectCssPlugin(config: ResolvedConfig): void;
+export declare function injectCssPostPlugin(config: ResolvedConfig, newCssPostPlugin: Plugin): void;
+export declare function replacePlugins(plugins: Plugin[], config: ResolvedConfig): void;
+export declare function removePlugins(plugins: string | string[], config: ResolvedConfig): void;

package/dist/vite/utils/plugin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removePlugins = exports.replacePlugins = exports.injectCssPostPlugin = exports.injectCssPlugin = exports.injectAssetPlugin = void 0;
+const shared_1 = require("@vue/shared");
+const asset_1 = require("../plugins/vitejs/plugins/asset");
+const css_1 = require("../plugins/vitejs/plugins/css");
+function injectAssetPlugin(config) {
+    replacePlugins([(0, asset_1.assetPlugin)(config)], config);
+}
+exports.injectAssetPlugin = injectAssetPlugin;
+function injectCssPlugin(config) {
+    replacePlugins([(0, css_1.cssPlugin)(config)], config);
+}
+exports.injectCssPlugin = injectCssPlugin;
+function injectCssPostPlugin(config, newCssPostPlugin) {
+    const oldCssPostPlugin = config.plugins.find((p) => p.name === newCssPostPlugin.name);
+    // 直接覆盖原有方法，不能删除，替换，因为 unocss 在 pre 阶段已经获取到了旧的 css-post 插件对象
+    if (oldCssPostPlugin) {
+        (0, shared_1.extend)(oldCssPostPlugin, newCssPostPlugin);
+    }
+}
+exports.injectCssPostPlugin = injectCssPostPlugin;
+function replacePlugins(plugins, config) {
+    plugins.forEach((plugin) => {
+        const index = config.plugins.findIndex((p) => p.name === plugin.name);
+        if (index > -1) {
+            ;
+            config.plugins.splice(index, 1, plugin);
+        }
+    });
+}
+exports.replacePlugins = replacePlugins;
+function removePlugins(plugins, config) {
+    if (!Array.isArray(plugins)) {
+        plugins = [plugins];
+    }
+    plugins.forEach((name) => {
+        const index = config.plugins.findIndex((p) => p.name === name);
+        if (index > -1) {
+            ;
+            config.plugins.splice(index, 1);
+        }
+    });
+}
+exports.removePlugins = removePlugins;

package/dist/vite/utils/url.d.ts

@@ -0,0 +1,28 @@
+export interface VueQuery {
+    vue?: boolean;
+    src?: boolean;
+    type?: 'script' | 'template' | 'style' | 'custom';
+    index?: number;
+    lang?: string;
+    raw?: boolean;
+}
+export declare function parseVueRequest(id: string): {
+    filename: string;
+    query: VueQuery;
+};
+export declare const isImportRequest: (url: string) => boolean;
+/**
+ * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
+ */
+export declare const FS_PREFIX = "/@fs/";
+/**
+ * Prefix for resolved Ids that are not valid browser import specifiers
+ */
+export declare const VALID_ID_PREFIX = "/@id/";
+export declare const CLIENT_PUBLIC_PATH = "/@vite/client";
+export declare const ENV_PUBLIC_PATH = "/@vite/env";
+export declare const isInternalRequest: (url: string) => boolean;
+export declare const queryRE: RegExp;
+export declare const hashRE: RegExp;
+export declare const cleanUrl: (url: string) => string;
+export declare function isJsFile(id: string): boolean;

package/dist/vite/utils/url.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsFile = exports.cleanUrl = exports.hashRE = exports.queryRE = exports.isInternalRequest = exports.ENV_PUBLIC_PATH = exports.CLIENT_PUBLIC_PATH = exports.VALID_ID_PREFIX = exports.FS_PREFIX = exports.isImportRequest = exports.parseVueRequest = void 0;
+const path_1 = __importDefault(require("path"));
+const querystring_1 = __importDefault(require("querystring"));
+const constants_1 = require("../../constants");
+function parseVueRequest(id) {
+    const [filename, rawQuery] = id.split(`?`, 2);
+    const query = querystring_1.default.parse(rawQuery);
+    if (query.vue != null) {
+        query.vue = true;
+    }
+    if (query.src != null) {
+        query.src = true;
+    }
+    if (query.index != null) {
+        query.index = Number(query.index);
+    }
+    if (query.raw != null) {
+        query.raw = true;
+    }
+    return {
+        filename,
+        query,
+    };
+}
+exports.parseVueRequest = parseVueRequest;
+const importQueryRE = /(\?|&)import=?(?:&|$)/;
+const isImportRequest = (url) => importQueryRE.test(url);
+exports.isImportRequest = isImportRequest;
+/**
+ * Prefix for resolved fs paths, since windows paths may not be valid as URLs.
+ */
+exports.FS_PREFIX = `/@fs/`;
+/**
+ * Prefix for resolved Ids that are not valid browser import specifiers
+ */
+exports.VALID_ID_PREFIX = `/@id/`;
+exports.CLIENT_PUBLIC_PATH = `/@vite/client`;
+exports.ENV_PUBLIC_PATH = `/@vite/env`;
+const internalPrefixes = [
+    exports.FS_PREFIX,
+    exports.VALID_ID_PREFIX,
+    exports.CLIENT_PUBLIC_PATH,
+    exports.ENV_PUBLIC_PATH,
+];
+const InternalPrefixRE = new RegExp(`^(?:${internalPrefixes.join('|')})`);
+const isInternalRequest = (url) => InternalPrefixRE.test(url);
+exports.isInternalRequest = isInternalRequest;
+exports.queryRE = /\?.*$/;
+exports.hashRE = /#.*$/;
+const cleanUrl = (url) => url.replace(exports.hashRE, '').replace(exports.queryRE, '');
+exports.cleanUrl = cleanUrl;
+function isJsFile(id) {
+    const isJs = constants_1.EXTNAME_JS_RE.test(id);
+    if (isJs) {
+        return true;
+    }
+    const { filename, query } = parseVueRequest(id);
+    const isVueJs = constants_1.EXTNAME_VUE.includes(path_1.default.extname(filename)) && !query.vue;
+    if (isVueJs) {
+        return true;
+    }
+    return false;
+}
+exports.isJsFile = isJsFile;

package/dist/vite/utils/utils.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedConfig, UserConfig } from 'vite';
+export declare function withSourcemap(config: ResolvedConfig): boolean;
+export declare function isInHybridNVue(config: UserConfig | ResolvedConfig): boolean;

package/dist/vite/utils/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInHybridNVue = exports.withSourcemap = void 0;
+function withSourcemap(config) {
+    if (config.command === 'serve') {
+        return true;
+    }
+    return !!config.build.sourcemap;
+}
+exports.withSourcemap = withSourcemap;
+function isInHybridNVue(config) {
+    return config.nvue && process.env.UNI_RENDERER !== 'native';
+}
+exports.isInHybridNVue = isInHybridNVue;

package/dist/vue/babel.d.ts

@@ -0,0 +1,3 @@
+import * as BabelCore from '@babel/core';
+import type { PluginObj } from '@babel/core';
+export declare function transformUniH5Jsx({ types }: typeof BabelCore): PluginObj;

package/dist/vue/babel.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformUniH5Jsx = void 0;
+const uni_shared_1 = require("@dcloudio/uni-shared");
+function transformUniH5Jsx({ types }) {
+    return {
+        name: 'babel-plugin-uni-h5-jsx',
+        visitor: {
+            JSXOpeningElement({ node: { name } }) {
+                if (types.isJSXIdentifier(name) && (0, uni_shared_1.isBuiltInComponent)(name.name)) {
+                    name.name = 'v-uni-' + name.name;
+                }
+            },
+        },
+    };
+}
+exports.transformUniH5Jsx = transformUniH5Jsx;

package/dist/vue/index.d.ts

@@ -0,0 +1,4 @@
+export * from './transforms';
+export * from './utils';
+export { transformUniH5Jsx } from './babel';
+export { isExternalUrl } from './transforms/templateUtils';

package/dist/vue/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExternalUrl = exports.transformUniH5Jsx = void 0;
+__exportStar(require("./transforms"), exports);
+__exportStar(require("./utils"), exports);
+var babel_1 = require("./babel");
+Object.defineProperty(exports, "transformUniH5Jsx", { enumerable: true, get: function () { return babel_1.transformUniH5Jsx; } });
+var templateUtils_1 = require("./transforms/templateUtils");
+Object.defineProperty(exports, "isExternalUrl", { enumerable: true, get: function () { return templateUtils_1.isExternalUrl; } });

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

@@ -0,0 +1,13 @@
+export * from './transformRef';
+export * from './transformPageHead';
+export * from './transformComponent';
+export * from './transformEvent';
+export * from './transformTag';
+export { createAssetUrlTransformWithOptions } from './templateTransformAssetUrl';
+export { createSrcsetTransformWithOptions } from './templateTransformSrcset';
+export { ATTR_DATASET_EVENT_OPTS, createTransformOn, defaultMatch as matchTransformOn, } from './vOn';
+export { createTransformModel, defaultMatch as matchTransformModel, } from './vModel';
+export declare const transformH5BuiltInComponents: import("@vue/compiler-core").NodeTransform;
+export declare const transformMatchMedia: import("@vue/compiler-core").NodeTransform;
+export declare const transformTapToClick: import("@vue/compiler-core").NodeTransform;
+export declare const transformComponentLink: (node: import("@vue/compiler-core").RootNode | import("@vue/compiler-core").TemplateChildNode, context: import("@vue/compiler-core").TransformContext) => void;

package/dist/vue/transforms/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformComponentLink = exports.transformTapToClick = exports.transformMatchMedia = exports.transformH5BuiltInComponents = exports.matchTransformModel = exports.createTransformModel = exports.matchTransformOn = exports.createTransformOn = exports.ATTR_DATASET_EVENT_OPTS = exports.createSrcsetTransformWithOptions = exports.createAssetUrlTransformWithOptions = void 0;
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const transformTag_1 = require("./transformTag");
+const transformEvent_1 = require("./transformEvent");
+const transformComponent_1 = require("./transformComponent");
+const constants_1 = require("../../mp/constants");
+__exportStar(require("./transformRef"), exports);
+__exportStar(require("./transformPageHead"), exports);
+__exportStar(require("./transformComponent"), exports);
+__exportStar(require("./transformEvent"), exports);
+__exportStar(require("./transformTag"), exports);
+var templateTransformAssetUrl_1 = require("./templateTransformAssetUrl");
+Object.defineProperty(exports, "createAssetUrlTransformWithOptions", { enumerable: true, get: function () { return templateTransformAssetUrl_1.createAssetUrlTransformWithOptions; } });
+var templateTransformSrcset_1 = require("./templateTransformSrcset");
+Object.defineProperty(exports, "createSrcsetTransformWithOptions", { enumerable: true, get: function () { return templateTransformSrcset_1.createSrcsetTransformWithOptions; } });
+var vOn_1 = require("./vOn");
+Object.defineProperty(exports, "ATTR_DATASET_EVENT_OPTS", { enumerable: true, get: function () { return vOn_1.ATTR_DATASET_EVENT_OPTS; } });
+Object.defineProperty(exports, "createTransformOn", { enumerable: true, get: function () { return vOn_1.createTransformOn; } });
+Object.defineProperty(exports, "matchTransformOn", { enumerable: true, get: function () { return vOn_1.defaultMatch; } });
+var vModel_1 = require("./vModel");
+Object.defineProperty(exports, "createTransformModel", { enumerable: true, get: function () { return vModel_1.createTransformModel; } });
+Object.defineProperty(exports, "matchTransformModel", { enumerable: true, get: function () { return vModel_1.defaultMatch; } });
+exports.transformH5BuiltInComponents = (0, transformTag_1.createTransformTag)(uni_shared_1.BUILT_IN_TAG_NAMES.reduce((tags, tag) => ((tags[tag] = uni_shared_1.COMPONENT_PREFIX + tag), tags), {}));
+exports.transformMatchMedia = (0, transformTag_1.createTransformTag)({
+    'match-media': 'uni-match-media',
+});
+exports.transformTapToClick = (0, transformEvent_1.createTransformEvent)({
+    tap: (node) => {
+        // 地图组件有自己特定的 tap 事件
+        if (node.tag === 'map' || node.tag === 'v-uni-map') {
+            return 'tap';
+        }
+        return 'click';
+    },
+});
+exports.transformComponentLink = (0, transformComponent_1.createTransformComponentLink)(constants_1.COMPONENT_BIND_LINK);

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

@@ -0,0 +1,33 @@
+import { NodeTransform } from '@vue/compiler-core';
+export interface AssetURLTagConfig {
+    [name: string]: string[];
+}
+export interface AssetURLOptions {
+    /**
+     * If base is provided, instead of transforming relative asset urls into
+     * imports, they will be directly rewritten to absolute urls.
+     */
+    base?: string | null;
+    /**
+     * If true, also processes absolute urls.
+     */
+    includeAbsolute?: boolean;
+    tags?: AssetURLTagConfig;
+}
+export declare const defaultAssetUrlOptions: Required<AssetURLOptions>;
+export declare const normalizeOptions: (options: AssetURLOptions | AssetURLTagConfig) => Required<AssetURLOptions>;
+export declare const createAssetUrlTransformWithOptions: (options: Required<AssetURLOptions>) => NodeTransform;
+/**
+ * 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 })
+ * ```
+ */
+export declare const transformAssetUrl: NodeTransform;