@dcloudio/vite-plugin-uni 0.0.1-nvue3.3030820220125001

package/dist/configResolved/options.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initOptions = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const jsonc_parser_1 = require("jsonc-parser");
+function resolveBase() {
+    const manifest = (0, jsonc_parser_1.parse)(fs_1.default.readFileSync(path_1.default.join(process.env.UNI_INPUT_DIR, 'manifest.json'), 'utf8'));
+    return (manifest.h5 && manifest.h5.router && manifest.h5.router.base) || '/';
+}
+function initOptions(options, config) {
+    options.base = resolveBase();
+    options.outputDir = process.env.UNI_OUTPUT_DIR;
+    options.assetsDir = config.build.assetsDir;
+}
+exports.initOptions = initOptions;

package/dist/configResolved/plugins/index.d.ts

@@ -0,0 +1,8 @@
+import { ResolvedConfig } from 'vite';
+import { FilterPattern } from '@rollup/pluginutils';
+import { VitePluginUniResolvedOptions } from '../..';
+export interface UniPluginFilterOptions extends VitePluginUniResolvedOptions {
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}
+export declare function initPlugins(config: ResolvedConfig, options: VitePluginUniResolvedOptions): void;

package/dist/configResolved/plugins/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPlugins = void 0;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const pre_1 = require("./pre");
+const json_1 = require("./json");
+const preCss_1 = require("./preCss");
+const static_1 = require("./static");
+const preVue_1 = require("./preVue");
+const ssr_1 = require("./ssr");
+const resolveId_1 = require("./resolveId");
+const debugPlugin = (0, debug_1.default)('uni:plugin');
+const UNI_H5_RE = /@dcloudio\/uni-h5/;
+const uniPrePluginOptions = {
+    exclude: [...uni_cli_shared_1.COMMON_EXCLUDE, UNI_H5_RE],
+};
+const uniPreCssPluginOptions = {
+    exclude: [...uni_cli_shared_1.COMMON_EXCLUDE, UNI_H5_RE],
+};
+function initPlugins(config, options) {
+    const plugins = config.plugins;
+    addPlugin(plugins, (0, resolveId_1.uniResolveIdPlugin)(options), 'vite:resolve', 'pre');
+    addPlugin(plugins, (0, pre_1.uniPrePlugin)(config, (0, shared_1.extend)(uniPrePluginOptions, options)), 0, 'pre');
+    addPlugin(plugins, (0, preCss_1.uniPreCssPlugin)(config, (0, shared_1.extend)(uniPreCssPluginOptions, options)), 'vite:css');
+    addPlugin(plugins, (0, preVue_1.uniPreVuePlugin)(), 'vite:vue', 'pre');
+    addPlugin(plugins, (0, ssr_1.uniSSRPlugin)(config, (0, shared_1.extend)({ exclude: [...uni_cli_shared_1.COMMON_EXCLUDE] }, options)), 'vite:vue');
+    addPlugin(plugins, (0, json_1.uniJsonPlugin)(options), 'vite:json', 'pre');
+    addPlugin(plugins, (0, static_1.uniStaticPlugin)(options, config), 'vite:asset', 'pre');
+    if ((0, uni_cli_shared_1.isInHBuilderX)()) {
+        try {
+            require(path_1.default.resolve(process.env.UNI_HBUILDERX_PLUGINS, 'uni_helpers/lib/bytenode'));
+            const { V } = require(path_1.default.join(process.env.UNI_HBUILDERX_PLUGINS, 'uni_helpers'));
+            addPlugin(plugins, V({ dir: process.env.UNI_INPUT_DIR }), 0, 'pre');
+        }
+        catch (e) { }
+    }
+    if (process.env.DEBUG) {
+        debugPlugin(plugins.length);
+        debugPlugin(plugins.map((p) => p.name));
+    }
+}
+exports.initPlugins = initPlugins;
+function addPlugin(plugins, plugin, index, type = 'post') {
+    if (typeof index === 'string') {
+        index = plugins.findIndex((plugin) => plugin.name === index);
+    }
+    return plugins.splice(index + (type === 'pre' ? 0 : 1), 0, plugin);
+}

package/dist/configResolved/plugins/json.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vite';
+import { VitePluginUniResolvedOptions } from '../..';
+export declare function uniJsonPlugin(options: VitePluginUniResolvedOptions): Plugin;

package/dist/configResolved/plugins/json.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniJsonPlugin = void 0;
+const jsonc_parser_1 = require("jsonc-parser");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const jsonExtRE = /\.json($|\?)(?!commonjs-proxy)/;
+const SPECIAL_QUERY_RE = /[\?&](?:worker|sharedworker|raw|url)\b/;
+function uniJsonPlugin(options) {
+    return {
+        name: 'uni:json',
+        transform(code, id) {
+            if (!jsonExtRE.test(id))
+                return null;
+            if (SPECIAL_QUERY_RE.test(id))
+                return null;
+            if (id.endsWith('.json.js'))
+                return null;
+            // preprocess
+            if (code.includes('#endif')) {
+                code = (0, uni_cli_shared_1.preJs)(code);
+            }
+            let jsonObj = (0, jsonc_parser_1.parse)(code);
+            if ((0, uni_cli_shared_1.isUniAppLocaleFile)(id)) {
+                jsonObj = jsonObj.common || {};
+            }
+            return {
+                code: JSON.stringify(jsonObj),
+                map: null,
+            };
+        },
+    };
+}
+exports.uniJsonPlugin = uniJsonPlugin;

package/dist/configResolved/plugins/pre.d.ts

@@ -0,0 +1,3 @@
+import { Plugin, ResolvedConfig } from 'vite';
+import { UniPluginFilterOptions } from '.';
+export declare function uniPrePlugin(config: ResolvedConfig, options: UniPluginFilterOptions): Plugin;

package/dist/configResolved/plugins/pre.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniPrePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugPreJs = (0, debug_1.default)('uni:pre-js');
+const debugPreHtml = (0, debug_1.default)('uni:pre-html');
+const debugPreJsTry = (0, debug_1.default)('uni:pre-js-try');
+const PRE_JS_EXTNAME = ['.json', '.css'].concat(uni_cli_shared_1.EXTNAME_VUE).concat(uni_cli_shared_1.EXTNAME_JS);
+const PRE_HTML_EXTNAME = uni_cli_shared_1.EXTNAME_VUE;
+function uniPrePlugin(config, options) {
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
+    return {
+        name: 'uni:pre',
+        transform(code, id) {
+            if (!filter(id)) {
+                return;
+            }
+            const { filename, query } = (0, uni_cli_shared_1.parseVueRequest)(id);
+            const extname = path_1.default.extname(filename);
+            const isHtml = query.type === 'template' || PRE_HTML_EXTNAME.includes(extname);
+            const isJs = PRE_JS_EXTNAME.includes(extname);
+            const isPre = isHtml || isJs;
+            if (isPre) {
+                debugPreJsTry(id);
+            }
+            const hasEndif = isPre && code.includes('#endif');
+            if (!hasEndif) {
+                return;
+            }
+            if (isHtml) {
+                code = (0, uni_cli_shared_1.preHtml)(code);
+                debugPreHtml(id);
+            }
+            if (isJs) {
+                code = (0, uni_cli_shared_1.preJs)(code);
+                debugPreJs(id);
+            }
+            return {
+                code,
+                map: (0, uni_cli_shared_1.withSourcemap)(config) ? this.getCombinedSourcemap() : null,
+            };
+        },
+    };
+}
+exports.uniPrePlugin = uniPrePlugin;

package/dist/configResolved/plugins/preCss.d.ts

@@ -0,0 +1,7 @@
+import { Plugin, ResolvedConfig } from 'vite';
+import { UniPluginFilterOptions } from '.';
+/**
+ * preprocess css
+ * @param options
+ */
+export declare function uniPreCssPlugin(config: ResolvedConfig, options: UniPluginFilterOptions): Plugin;

package/dist/configResolved/plugins/preCss.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniPreCssPlugin = void 0;
+const debug_1 = __importDefault(require("debug"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugPre = (0, debug_1.default)('uni:pre-css');
+const debugPreTry = (0, debug_1.default)('uni:pre-css-try');
+const cssLangs = `\\.(css|less|sass|scss|styl|stylus|postcss)($|\\?)`;
+const cssLangRE = new RegExp(cssLangs);
+/**
+ * preprocess css
+ * @param options
+ */
+function uniPreCssPlugin(config, options) {
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
+    return {
+        name: 'uni:pre-css',
+        transform(code, id) {
+            if (!cssLangRE.test(id)) {
+                return;
+            }
+            if (!filter(id)) {
+                return;
+            }
+            debugPreTry(id);
+            if (!code.includes('#endif')) {
+                return;
+            }
+            debugPre(id);
+            return {
+                code: (0, uni_cli_shared_1.preJs)(code),
+                map: (0, uni_cli_shared_1.withSourcemap)(config) ? this.getCombinedSourcemap() : null,
+            };
+        },
+    };
+}
+exports.uniPreCssPlugin = uniPreCssPlugin;

package/dist/configResolved/plugins/preVue.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+import { RootNode, ElementNode } from '@vue/compiler-core';
+export declare function uniPreVuePlugin(): Plugin;
+export declare function parseBlockCode(ast: RootNode, code: string): string;
+export declare function parseWxsNodes(ast: RootNode): ElementNode[];
+export declare function parseWxsCode(wxsNodes: ElementNode[], code: string): string;

package/dist/configResolved/plugins/preVue.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWxsCode = exports.parseWxsNodes = exports.parseBlockCode = exports.uniPreVuePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugPreVue = (0, debug_1.default)('uni:pre-vue');
+const BLOCK_RE = /<\/block>/;
+const WXS_LANG_RE = /lang=["|'](renderjs|wxs)["|']/;
+const WXS_ATTRS = ['wxs', 'renderjs'];
+function uniPreVuePlugin() {
+    let isNVue = false;
+    return {
+        name: 'uni:pre-vue',
+        config(config) {
+            isNVue = config.nvue;
+        },
+        async transform(code, id) {
+            const { filename, query } = (0, uni_cli_shared_1.parseVueRequest)(id);
+            if (query.vue) {
+                return;
+            }
+            if (!uni_cli_shared_1.EXTNAME_VUE.includes(path_1.default.extname(filename))) {
+                return;
+            }
+            // 清空当前页面已缓存的 filter 信息
+            (0, uni_cli_shared_1.clearMiniProgramTemplateFilter)((0, uni_cli_shared_1.removeExt)((0, uni_cli_shared_1.normalizeMiniProgramFilename)(id, process.env.UNI_INPUT_DIR)));
+            const hasBlock = BLOCK_RE.test(code);
+            // nvue 不支持 renderjs，wxs
+            const hasWxs = !isNVue && WXS_LANG_RE.test(code);
+            if (!hasBlock && !hasWxs) {
+                return;
+            }
+            debugPreVue(id);
+            const watchFiles = [];
+            const errors = [];
+            let ast = (0, uni_cli_shared_1.parseVue)(code, errors);
+            if (hasBlock) {
+                code = parseBlockCode(ast, code);
+            }
+            if (hasWxs) {
+                if (hasBlock) {
+                    // 重新解析新的 code
+                    ast = (0, uni_cli_shared_1.parseVue)(code, errors);
+                }
+                const wxsNodes = parseWxsNodes(ast);
+                code = parseWxsCode(wxsNodes, code);
+                // add watch
+                for (const wxsNode of wxsNodes) {
+                    const srcProp = wxsNode.props.find((prop) => prop.type === 6 /* ATTRIBUTE */ && prop.name === 'src');
+                    if (srcProp && srcProp.value) {
+                        const resolveId = await this.resolve(srcProp.value.content, id);
+                        if (resolveId) {
+                            watchFiles.push(resolveId.id);
+                        }
+                    }
+                }
+            }
+            // if (errors.length) {
+            //   this.error(errors.join('\n'))
+            // }
+            watchFiles.forEach((file) => this.addWatchFile(file));
+            return {
+                code,
+                map: null,
+            };
+        },
+    };
+}
+exports.uniPreVuePlugin = uniPreVuePlugin;
+function traverseChildren({ children }, blockNodes) {
+    children.forEach((node) => traverseNode(node, blockNodes));
+}
+function traverseNode(node, blockNodes) {
+    if ((0, uni_cli_shared_1.isElementNode)(node) && node.tag === 'block') {
+        blockNodes.push(node);
+    }
+    if (node.type === 10 /* IF_BRANCH */ ||
+        node.type === 11 /* FOR */ ||
+        node.type === 1 /* ELEMENT */ ||
+        node.type === 0 /* ROOT */) {
+        traverseChildren(node, blockNodes);
+    }
+}
+function parseBlockCode(ast, code) {
+    const blockNodes = [];
+    traverseNode(ast, blockNodes);
+    if (blockNodes.length) {
+        return parseBlockNode(code, blockNodes);
+    }
+    return code;
+}
+exports.parseBlockCode = parseBlockCode;
+const BLOCK_END_LEN = '</block>'.length;
+const BLOCK_START_LEN = '<block'.length;
+function parseBlockNode(code, blocks) {
+    const magicString = new compiler_sfc_1.MagicString(code);
+    blocks.forEach(({ loc }) => {
+        const startOffset = loc.start.offset;
+        const endOffset = loc.end.offset;
+        magicString.overwrite(startOffset, startOffset + BLOCK_START_LEN, '<template');
+        magicString.overwrite(endOffset - BLOCK_END_LEN, endOffset, '</template>');
+    });
+    return magicString.toString();
+}
+function parseWxsNodes(ast) {
+    return ast.children.filter((node) => node.type === 1 /* ELEMENT */ &&
+        node.tag === 'script' &&
+        node.props.find((prop) => prop.name === 'lang' &&
+            prop.type === 6 /* ATTRIBUTE */ &&
+            prop.value &&
+            WXS_ATTRS.includes(prop.value.content)));
+}
+exports.parseWxsNodes = parseWxsNodes;
+function parseWxsCode(wxsNodes, code) {
+    if (wxsNodes.length) {
+        code = parseWxsNode(code, wxsNodes);
+    }
+    return code;
+}
+exports.parseWxsCode = parseWxsCode;
+const SCRIPT_END_LEN = '</script>'.length;
+const SCRIPT_START_LEN = '<script'.length;
+function parseWxsNode(code, nodes) {
+    const magicString = new compiler_sfc_1.MagicString(code);
+    nodes.forEach(({ loc, props }) => {
+        const langAttr = props.find((prop) => prop.name === 'lang');
+        const moduleAttr = props.find((prop) => prop.name === 'module');
+        const startOffset = loc.start.offset;
+        const endOffset = loc.end.offset;
+        const lang = langAttr.value.content;
+        const langStartOffset = langAttr.loc.start.offset;
+        magicString.overwrite(startOffset, startOffset + SCRIPT_START_LEN, '<' + lang); // <renderjs or <wxs
+        magicString.overwrite(langStartOffset, langStartOffset + ('lang="' + lang + '"').length, ''); // remove lang="renderjs" or lang="wxs"
+        magicString.overwrite(endOffset - SCRIPT_END_LEN, endOffset, '</' + lang + '>'); //</renderjs> or </wxs>
+        if (moduleAttr) {
+            const moduleStartOffset = moduleAttr.loc.start.offset;
+            magicString.overwrite(moduleStartOffset, moduleStartOffset + 'module'.length, 'name'); // module="echarts" => name="echarts"
+        }
+    });
+    return magicString.toString();
+}

package/dist/configResolved/plugins/resolveId.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from 'vite';
+import { VitePluginUniResolvedOptions } from '../..';
+declare const BUILT_IN_MODULES: {
+    'vue-router': string;
+    vuex: string;
+    'vue-i18n': string;
+    '@dcloudio/uni-app': string;
+    '@dcloudio/uni-stat': string;
+    '@dcloudio/uni-cloud': string;
+    '@dcloudio/uni-i18n': string;
+    '@dcloudio/uni-shared': string;
+};
+export declare type BuiltInModulesKey = keyof typeof BUILT_IN_MODULES;
+export declare function uniResolveIdPlugin(options: VitePluginUniResolvedOptions): Plugin;
+export {};

package/dist/configResolved/plugins/resolveId.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniResolveIdPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugResolve = (0, debug_1.default)('uni:resolve-id');
+const BUILT_IN_MODULES = {
+    'vue-router': 'dist/vue-router.esm-bundler.js',
+    vuex: 'dist/vuex.esm-bundler.js',
+    'vue-i18n': 'dist/vue-i18n.esm-bundler.js',
+    '@dcloudio/uni-app': 'dist/uni-app.es.js',
+    '@dcloudio/uni-stat': 'dist/uni-stat.es.js',
+    '@dcloudio/uni-cloud': 'dist/uni-cloud.es.js',
+    '@dcloudio/uni-i18n': 'dist/uni-i18n.es.js',
+    '@dcloudio/uni-shared': 'dist/uni-shared.es.js',
+};
+function uniResolveIdPlugin(options) {
+    const resolveCache = {};
+    return {
+        name: 'uni:resolve-id',
+        resolveId(id) {
+            const cache = resolveCache[id];
+            if (cache) {
+                debugResolve('cache', id, cache);
+                return cache;
+            }
+            if (BUILT_IN_MODULES[id]) {
+                return (resolveCache[id] = (0, uni_cli_shared_1.resolveBuiltIn)(path_1.default.join(id, BUILT_IN_MODULES[id])));
+            }
+        },
+    };
+}
+exports.uniResolveIdPlugin = uniResolveIdPlugin;

package/dist/configResolved/plugins/ssr.d.ts

@@ -0,0 +1,3 @@
+import { Plugin, ResolvedConfig } from 'vite';
+import { UniPluginFilterOptions } from '.';
+export declare function uniSSRPlugin(config: ResolvedConfig, options: UniPluginFilterOptions): Plugin;

package/dist/configResolved/plugins/ssr.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniSSRPlugin = void 0;
+const debug_1 = __importDefault(require("debug"));
+const crypto_1 = __importDefault(require("crypto"));
+const estree_walker_1 = require("estree-walker");
+const pluginutils_1 = require("@rollup/pluginutils");
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugSSR = (0, debug_1.default)('uni:ssr');
+const KEYED_FUNC_RE = /(ssrRef|shallowSsrRef)/;
+function uniSSRPlugin(config, options) {
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
+    return {
+        name: 'uni:ssr',
+        transform(code, id) {
+            if (!filter(id))
+                return null;
+            if (!KEYED_FUNC_RE.test(code)) {
+                return;
+            }
+            debugSSR('try', id);
+            const ast = this.parse(code);
+            const s = new compiler_sfc_1.MagicString(code);
+            (0, estree_walker_1.walk)(ast, {
+                enter(node) {
+                    if (!(0, uni_cli_shared_1.isCallExpression)(node)) {
+                        return;
+                    }
+                    const { callee, arguments: args } = node;
+                    if (args.length !== 1) {
+                        return;
+                    }
+                    const name = (0, uni_cli_shared_1.isIdentifier)(callee)
+                        ? callee.name
+                        : (0, uni_cli_shared_1.isMemberExpression)(callee) && (0, uni_cli_shared_1.isIdentifier)(callee.property)
+                            ? callee.property.name
+                            : '';
+                    if (name !== 'ssrRef' && name !== 'shallowSsrRef') {
+                        return;
+                    }
+                    const { end } = node;
+                    const key = id + '-' + node.end;
+                    debugSSR(key, name);
+                    s.appendLeft(end - 1, ", '" + createKey(`${id}-${end}`) + "'");
+                },
+            });
+            return {
+                code: s.toString(),
+                map: (0, uni_cli_shared_1.withSourcemap)(config) ? s.generateMap().toString() : null,
+            };
+        },
+    };
+}
+exports.uniSSRPlugin = uniSSRPlugin;
+function createKey(source) {
+    const hash = crypto_1.default.createHash('md5');
+    hash.update(source);
+    return hash.digest('base64').toString();
+}

package/dist/configResolved/plugins/static.d.ts

@@ -0,0 +1,9 @@
+import { Plugin, ResolvedConfig } from 'vite';
+import { UniPluginFilterOptions } from '.';
+/**
+ * 提供static等目录静态资源加载
+ * @param _options
+ * @param config
+ * @returns
+ */
+export declare function uniStaticPlugin(_options: UniPluginFilterOptions, config: ResolvedConfig): Plugin;

package/dist/configResolved/plugins/static.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniStaticPlugin = void 0;
+const debug_1 = __importDefault(require("debug"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const utils_1 = require("../../utils");
+const debugStatic = (0, debug_1.default)('uni:static');
+/**
+ * 提供static等目录静态资源加载
+ * @param _options
+ * @param config
+ * @returns
+ */
+function uniStaticPlugin(_options, config) {
+    const filter = (0, utils_1.createPublicFileFilter)();
+    return {
+        name: 'uni:static',
+        resolveId(id) {
+            if (!config.assetsInclude((0, uni_cli_shared_1.cleanUrl)(id))) {
+                return;
+            }
+            const publicFile = filter(id);
+            if (publicFile) {
+                debugStatic(id);
+                return id;
+            }
+        },
+        async load(id) {
+            if (!config.assetsInclude((0, uni_cli_shared_1.cleanUrl)(id))) {
+                return;
+            }
+            if (filter(id)) {
+                return `export default ${JSON.stringify(fileToUrl(id, config))}`;
+            }
+        },
+    };
+}
+exports.uniStaticPlugin = uniStaticPlugin;
+function fileToUrl(id, config) {
+    return config.base + id.slice(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite';
+import type { Options as VueOptions } from '@vitejs/plugin-vue';
+import type { Options as ViteLegacyOptions } from '@vitejs/plugin-legacy';
+import type { VueJSXPluginOptions } from '@vue/babel-plugin-jsx';
+import { CopyOptions } from '@dcloudio/uni-cli-shared';
+export interface VitePluginUniOptions {
+    inputDir?: string;
+    outputDir?: string;
+    vueOptions?: VueOptions;
+    vueJsxOptions?: (VueJSXPluginOptions & {
+        babelPlugins?: any[];
+    }) | boolean;
+    viteLegacyOptions?: ViteLegacyOptions | false;
+}
+export interface VitePluginUniResolvedOptions extends VitePluginUniOptions {
+    base: string;
+    command: ResolvedConfig['command'];
+    platform: UniApp.PLATFORM;
+    inputDir: string;
+    outputDir: string;
+    assetsDir: string;
+    devServer?: ViteDevServer;
+    copyOptions?: Required<CopyOptions>;
+}
+export { runDev, runBuild } from './cli/action';
+export default function uniPlugin(rawOptions?: VitePluginUniOptions): Plugin[];