2025/2/8第一次更新

node_modules/@dcloudio/vite-plugin-uni/dist/cli/action.d.ts

@@ -0,0 +1,5 @@
+import { type BuildOptions, type ServerOptions } from 'vite';
+import type { CliOptions } from '.';
+export declare function runDev(options: CliOptions & ServerOptions): Promise<undefined>;
+export declare function runBuild(options: CliOptions & BuildOptions): Promise<void>;
+export declare const stopProfiler: (log: (message: string) => void) => void | Promise<void>;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/action.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopProfiler = exports.runBuild = exports.runDev = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const shared_1 = require("@vue/shared");
+const vite_1 = require("vite");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const build_1 = require("./build");
+const server_1 = require("./server");
+const utils_1 = require("./utils");
+const easycom_1 = require("../utils/easycom");
+const uvue_1 = require("./uvue");
+async function runDev(options) {
+    (0, shared_1.extend)(options, {
+        watch: {},
+    });
+    if (process.env.UNI_MINIMIZE === 'true') {
+        ;
+        options.minify = true;
+    }
+    (0, utils_1.initEnv)('dev', options);
+    if (process.env.UNI_APP_X === 'true' &&
+        process.env.UNI_UTS_PLATFORM === 'app-android') {
+        return (0, uvue_1.runUVueAndroidDev)(options);
+    }
+    const createLogger = await Promise.resolve().then(() => __importStar(require('vite'))).then(({ createLogger }) => createLogger);
+    try {
+        if (options.platform === 'h5') {
+            const server = await (options.ssr
+                ? (0, server_1.createSSRServer)(options)
+                : (0, server_1.createServer)(options));
+            (0, easycom_1.initEasycom)(server.watcher);
+        }
+        else {
+            const watcher = (await (0, build_1.build)(options));
+            (0, easycom_1.initEasycom)();
+            let isFirstStart = true;
+            let isFirstEnd = true;
+            watcher.on('event', async (event) => {
+                if (event.code === 'BUNDLE_START') {
+                    if (isFirstStart) {
+                        isFirstStart = false;
+                        return;
+                    }
+                    (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.start']);
+                }
+                else if (event.code === 'BUNDLE_END') {
+                    event.result.close();
+                    if (isFirstEnd) {
+                        // 首次全量同步
+                        if (options.platform === 'app' ||
+                            options.platform === 'app-harmony') {
+                            process.env.UNI_APP_CHANGED_FILES = '';
+                        }
+                        if (options.platform === 'app') {
+                            process.env.UNI_APP_CHANGED_PAGES = '';
+                            process.env.UNI_APP_UTS_CHANGED_FILES = '';
+                        }
+                        isFirstEnd = false;
+                        (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end']);
+                        (0, utils_1.showRunPrompt)(options.platform);
+                        (0, utils_1.printStartupDuration)(createLogger(options.logLevel), false);
+                        if (process.env.UNI_UTS_ERRORS) {
+                            console.error(process.env.UNI_UTS_ERRORS);
+                        }
+                        if (process.env.UNI_UTS_TIPS) {
+                            console.warn(process.env.UNI_UTS_TIPS);
+                        }
+                        await (0, exports.stopProfiler)((message) => createLogger(options.logLevel).info(message));
+                        return;
+                    }
+                    if (options.platform === 'app') {
+                        const files = process.env.UNI_APP_CHANGED_FILES;
+                        const pages = process.env.UNI_APP_CHANGED_PAGES;
+                        const dex = process.env.UNI_APP_UTS_CHANGED_FILES;
+                        const changedFiles = pages || files;
+                        process.env.UNI_APP_CHANGED_PAGES = '';
+                        process.env.UNI_APP_CHANGED_FILES = '';
+                        process.env.UNI_APP_UTS_CHANGED_FILES = '';
+                        if ((changedFiles &&
+                            !changedFiles.includes(uni_cli_shared_1.APP_CONFIG_SERVICE) &&
+                            !changedFiles.includes(uni_cli_shared_1.APP_SERVICE_FILENAME)) ||
+                            dex) {
+                            if (pages) {
+                                return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end.pages'].replace('{pages}', changedFiles));
+                            }
+                            return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end.files'].replace('{files}', JSON.stringify(JSON.parse(changedFiles || JSON.stringify([])).concat(JSON.parse(dex || JSON.stringify([]))))));
+                        }
+                    }
+                    else if (options.platform === 'app-harmony') {
+                        const files = process.env.UNI_APP_CHANGED_FILES;
+                        if (files) {
+                            return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end.files'].replace('{files}', files));
+                        }
+                    }
+                    return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end']);
+                }
+                else if (event.code === 'END') {
+                    if (process.env.UNI_AUTOMATOR_WS_ENDPOINT) {
+                        setTimeout(() => {
+                            (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['build.failed']);
+                            process.exit(0);
+                        }, 2000);
+                    }
+                }
+            });
+        }
+    }
+    catch (e) {
+        if (options.platform === 'h5') {
+            console.error(`error when starting dev server:\n${e.stack || e}`);
+        }
+        else {
+            console.error(`error during build:\n${e.stack || e}`);
+        }
+        process.exit(1);
+    }
+}
+exports.runDev = runDev;
+async function runBuild(options) {
+    (0, utils_1.initEnv)('build', options);
+    if (process.env.UNI_APP_X === 'true' &&
+        process.env.UNI_UTS_PLATFORM === 'app-android') {
+        return (0, uvue_1.runUVueAndroidBuild)(options);
+    }
+    try {
+        await (options.ssr && options.platform === 'h5'
+            ? (0, build_1.buildSSR)(options)
+            : (0, build_1.build)(options));
+        await (0, exports.stopProfiler)((message) => (0, vite_1.createLogger)(options.logLevel).info(message));
+        console.log(uni_cli_shared_1.M['build.done']);
+        if (options.platform !== 'h5') {
+            (0, utils_1.showRunPrompt)(options.platform);
+        }
+        // 开发者可能用了三方插件，三方插件有可能阻止退出，导致HBuilderX打包状态识别不正确
+        if ((0, uni_cli_shared_1.isInHBuilderX)() ||
+            /* 需要排查为什么ext-api编译时没有自动结束 */ process.env
+                .UNI_COMPILE_TARGET === 'ext-api') {
+            process.exit(0);
+        }
+    }
+    catch (e) {
+        console.error(e.message || e);
+        console.error(`Build failed with errors.`);
+        process.exit(1);
+    }
+}
+exports.runBuild = runBuild;
+let profileSession = global.__vite_profile_session;
+let profileCount = 0;
+const stopProfiler = (log) => {
+    if (!profileSession)
+        return;
+    return new Promise((res, rej) => {
+        profileSession.post('Profiler.stop', (err, result) => {
+            // Write profile to disk, upload, etc.
+            if (!err) {
+                const outPath = path_1.default.resolve(process.env.UNI_INPUT_DIR, `./profile-${profileCount++}.cpuprofile`);
+                fs_1.default.writeFileSync(outPath, JSON.stringify(result.profile));
+                log(picocolors_1.default.yellow(`CPU profile written to ${picocolors_1.default.white(picocolors_1.default.dim(outPath))}`));
+                profileSession = undefined;
+                res();
+            }
+            else {
+                rej(err);
+            }
+        });
+    });
+};
+exports.stopProfiler = stopProfiler;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/build.d.ts

@@ -0,0 +1,8 @@
+import type { BuildOptions, InlineConfig } from 'vite';
+import type { CliOptions } from '.';
+import type { RollupWatcher } from 'rollup';
+export declare function buildByVite(inlineConfig: InlineConfig): Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | RollupWatcher>;
+export declare function build(options: CliOptions): Promise<RollupWatcher | void>;
+export declare function buildSSR(options: CliOptions): Promise<void>;
+export declare function initBuildOptions(options: CliOptions, build: BuildOptions): InlineConfig;
+export declare function buildApp(options: CliOptions): Promise<RollupWatcher | void>;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/build.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApp = exports.initBuildOptions = exports.buildSSR = exports.build = exports.buildByVite = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const utils_1 = require("./utils");
+async function buildByVite(inlineConfig) {
+    return Promise.resolve().then(() => __importStar(require('vite'))).then(({ build }) => build(inlineConfig));
+}
+exports.buildByVite = buildByVite;
+async function build(options) {
+    if (process.env.UNI_APP_X !== 'true' && options.platform === 'app') {
+        return buildApp(options);
+    }
+    return buildByVite((0, utils_1.addConfigFile)(initBuildOptions(options, (0, utils_1.cleanOptions)(options))));
+}
+exports.build = build;
+async function buildSSR(options) {
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    const ssrClientDir = path_1.default.resolve(outputDir, 'client');
+    process.env.UNI_OUTPUT_DIR = ssrClientDir;
+    const ssrBuildClientOptions = (0, utils_1.cleanOptions)(options);
+    ssrBuildClientOptions.ssrManifest = 'ssr-manifest.json';
+    ssrBuildClientOptions.outDir = process.env.UNI_OUTPUT_DIR;
+    process.env.UNI_SSR_CLIENT = 'true';
+    await buildByVite((0, utils_1.addConfigFile)(initBuildOptions(options, ssrBuildClientOptions)));
+    const ssrServerDir = path_1.default.resolve(outputDir, 'server');
+    process.env.UNI_OUTPUT_DIR = ssrServerDir;
+    const ssrBuildServerOptions = (0, utils_1.cleanOptions)(options);
+    ssrBuildServerOptions.ssr = path_1.default.resolve(process.env.UNI_INPUT_DIR, 'entry-server.js');
+    // 强制 cjs 输出
+    ssrBuildServerOptions.rollupOptions = {
+        output: {
+            format: 'cjs',
+        },
+    };
+    ssrBuildServerOptions.outDir = process.env.UNI_OUTPUT_DIR;
+    process.env.UNI_SSR_CLIENT = '';
+    process.env.UNI_SSR_SERVER = 'true';
+    await buildByVite((0, utils_1.addConfigFile)(initBuildOptions(options, ssrBuildServerOptions)));
+    // copy ssr-manfiest.json to server
+    const assets = ['ssr-manifest.json', 'index.html'];
+    assets.forEach((asset) => {
+        const ssrManifestFile = path_1.default.join(ssrClientDir, asset);
+        if (fs_extra_1.default.existsSync(ssrManifestFile)) {
+            fs_extra_1.default.copyFileSync(ssrManifestFile, path_1.default.join(ssrServerDir, asset));
+        }
+    });
+}
+exports.buildSSR = buildSSR;
+function initBuildOptions(options, build) {
+    return {
+        root: process.env.VITE_ROOT_DIR,
+        configFile: options.config,
+        base: options.base,
+        logLevel: options.logLevel,
+        clearScreen: options.clearScreen,
+        mode: options.mode,
+        build,
+    };
+}
+exports.initBuildOptions = initBuildOptions;
+function buildManifestJson() {
+    const platform = 'app';
+    const inputDir = process.env.UNI_INPUT_DIR;
+    const outputDir = process.env.UNI_OUTPUT_DIR;
+    const pkg = require(path_1.default.resolve(__dirname, '../../package.json'));
+    process.env.UNI_COMPILER_VERSION =
+        process.env.UNI_COMPILER_VERSION ||
+            pkg['uni-app']?.['compilerVersion'] ||
+            '';
+    const manifestJson = (0, uni_cli_shared_1.normalizeAppManifestJson)((0, uni_cli_shared_1.parseManifestJsonOnce)(inputDir), (0, uni_cli_shared_1.parsePagesJsonOnce)(inputDir, platform));
+    fs_extra_1.default.outputFileSync(path_1.default.resolve(outputDir, 'manifest.json'), JSON.stringify(manifestJson, null, 2));
+}
+async function buildApp(options) {
+    if (options.manifest) {
+        return buildManifestJson();
+    }
+    let appWatcher;
+    if (options.watch) {
+        appWatcher = new AppWatcher();
+    }
+    if (process.env.UNI_RENDERER === 'native') {
+        // 纯原生渲染时，main.js + App.vue 需要跟页面分开，独立编译（因为需要包含 Vuex 等共享内容）
+        process.env.UNI_COMPILER = 'nvue';
+        process.env.UNI_RENDERER_NATIVE = 'appService';
+        const nvueAppBuilder = await buildByVite((0, utils_1.addConfigFile)((0, shared_1.extend)({ nvueAppService: true, nvue: true }, initBuildOptions(options, (0, utils_1.cleanOptions)(options)))));
+        if (appWatcher) {
+            appWatcher.setFirstWatcher(nvueAppBuilder);
+        }
+        process.env.UNI_RENDERER_NATIVE = 'pages';
+        const nvueBuilder = await buildByVite((0, utils_1.addConfigFile)((0, shared_1.extend)({ nvue: true }, initBuildOptions(options, (0, utils_1.cleanOptions)(options)))));
+        if (appWatcher) {
+            appWatcher.setSecondWatcher(nvueBuilder);
+            return appWatcher;
+        }
+        return;
+    }
+    // 指定为 vue 方便 App 插件初始化 vue 所需插件列表
+    process.env.UNI_COMPILER = 'vue';
+    const vueBuilder = await buildByVite((0, utils_1.addConfigFile)(initBuildOptions(options, (0, utils_1.cleanOptions)(options))));
+    if (!(0, uni_cli_shared_1.isNormalCompileTarget)()) {
+        // 不需要 nvue 编译器
+        return vueBuilder;
+    }
+    if (appWatcher) {
+        appWatcher.setFirstWatcher(vueBuilder);
+    }
+    // 临时指定为 nvue 方便 App 插件初始化 nvue 所需插件列表
+    process.env.UNI_COMPILER = 'nvue';
+    const nvueBuilder = await buildByVite((0, utils_1.addConfigFile)((0, shared_1.extend)({ nvue: true }, initBuildOptions(options, (0, utils_1.cleanOptions)(options)))));
+    // 还原为 vue
+    process.env.UNI_COMPILER = 'vue';
+    if (appWatcher) {
+        appWatcher.setSecondWatcher(nvueBuilder);
+        return appWatcher;
+    }
+}
+exports.buildApp = buildApp;
+class AppWatcher {
+    constructor() {
+        this._firstStart = false;
+        this._firstEnd = false;
+        this._secondStart = false;
+        this._secondEnd = false;
+    }
+    on(_event, callback) {
+        this._callback = callback;
+    }
+    setFirstWatcher(firstWatcher) {
+        firstWatcher.on('event', (event) => {
+            if (event.code === 'BUNDLE_START') {
+                this._bundleFirstStart(event);
+            }
+            else if (event.code === 'BUNDLE_END') {
+                this._bundleFirstEnd(event);
+            }
+        });
+    }
+    setSecondWatcher(secondWatcher) {
+        secondWatcher.on('event', (event) => {
+            if (event.code === 'BUNDLE_START') {
+                this._bundleSecondStart(event);
+            }
+            else if (event.code === 'BUNDLE_END') {
+                this._bundleSecondEnd(event);
+            }
+        });
+    }
+    _bundleFirstStart(event) {
+        this._firstStart = true;
+        this._bundleStart(event);
+    }
+    _bundleFirstEnd(event) {
+        this._firstEnd = true;
+        this._bundleEnd(event);
+    }
+    _bundleSecondStart(event) {
+        this._secondStart = true;
+        this._bundleStart(event);
+    }
+    _bundleSecondEnd(event) {
+        this._secondEnd = true;
+        this._bundleEnd(event);
+    }
+    _bundleStart(event) {
+        if (this._firstStart && this._secondStart) {
+            this._callback(event);
+        }
+    }
+    _bundleEnd(event) {
+        if (this._firstEnd && this._secondEnd) {
+            this._callback(event);
+        }
+    }
+}

node_modules/@dcloudio/vite-plugin-uni/dist/cli/index.d.ts

@@ -0,0 +1,26 @@
+import type { LogLevel } from 'vite';
+export interface CliOptions {
+    '--'?: string[];
+    c?: boolean | string;
+    config?: string;
+    platform?: string;
+    p?: string;
+    ssr?: boolean;
+    base?: string;
+    debug?: boolean | string;
+    d?: boolean | string;
+    filter?: string;
+    f?: string;
+    logLevel?: LogLevel;
+    l?: LogLevel;
+    m?: string;
+    mode?: string;
+    clearScreen?: boolean;
+    autoHost?: string;
+    autoPort?: number;
+    devtools?: boolean;
+    devtoolsHost?: string;
+    devtoolsPort?: number;
+    subpackage?: string;
+    plugin?: boolean;
+}

node_modules/@dcloudio/vite-plugin-uni/dist/cli/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cac_1 = require("cac");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const utils_1 = require("./utils");
+const action_1 = require("./action");
+(0, uni_cli_shared_1.fixBinaryPath)();
+const cli = (0, cac_1.cac)('uni');
+cli
+    .option('-c, --config <file>', `[string] use specified config file`)
+    .option('-p, --platform [platform]', '[string] ' + utils_1.PLATFORMS.join(' | '), {
+    default: 'h5',
+})
+    .option('--base <path>', `[string] public base path (default: /)`)
+    .option('-ssr', '[boolean] server-side rendering', {
+    default: false,
+})
+    .option('-l, --logLevel <level>', `[string] silent | error | warn | all`)
+    .option('--clearScreen', `[boolean] allow/disable clear screen when logging`)
+    .option('-d, --debug [feat]', `[string | boolean] show debug logs`)
+    .option('-f, --filter <filter>', `[string] filter debug logs`)
+    .option('-m, --mode <mode>', `[string] set env mode`)
+    .option('--minify [minifier]', `[boolean | "terser" | "esbuild"] enable/disable minification, ` +
+    `or specify minifier to use (default: terser)`)
+    .option('--autoHost [autoHost]', `[string] specify automator hostname`)
+    .option('--autoPort [autoPort]', `[number] specify automator port`)
+    .option('--devtools', `[boolean] enable devtools`)
+    .option('--devtoolsHost [devtoolsHost]', `[string] specify devtools hostname`)
+    .option('--devtoolsPort [devtoolsPort]', `[number] specify devtools port`)
+    .option('--subpackage [subpackage]', `[string] specify subpackage to build`)
+    .option('--plugin', `[boolean] build plugin`);
+cli
+    .command('')
+    .alias('dev')
+    .option('--host [host]', `[string] specify hostname`)
+    .option('--port <port>', `[number] specify port`)
+    .option('--https', `[boolean] use TLS + HTTP/2`)
+    .option('--open [path]', `[boolean | string] open browser on startup`)
+    .option('--cors', `[boolean] enable CORS`)
+    .option('--strictPort', `[boolean] exit if specified port is already in use`)
+    .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
+    .action(action_1.runDev);
+cli
+    .command('build')
+    .option('--outDir <dir>', `[string] output directory (default: dist)`)
+    .option('--assetsInlineLimit <number>', `[number] static asset base64 inline threshold in bytes (default: 4096)`)
+    .option('--sourcemap', `[boolean] output source maps for build (default: false)`)
+    .option('--manifest', `[boolean] emit build manifest json`)
+    .option('--ssrManifest', `[boolean] emit ssr manifest json`)
+    .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`, {
+    default: true,
+})
+    .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
+    .action(action_1.runBuild);
+cli.help();
+cli.version(require('../../package.json').version);
+cli.parse();

node_modules/@dcloudio/vite-plugin-uni/dist/cli/nvue.d.ts

@@ -0,0 +1 @@
+export declare function initNVueEnv(): void;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/nvue.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initNVueEnv = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function initNVueEnv() {
+    if (process.env.UNI_APP_X === 'true') {
+        return;
+    }
+    const manifestJson = (0, uni_cli_shared_1.parseManifestJsonOnce)(process.env.UNI_INPUT_DIR);
+    if ((0, uni_cli_shared_1.getAppRenderer)(manifestJson) === 'native') {
+        process.env.UNI_RENDERER = 'native';
+    }
+    const nvueCompiler = (0, uni_cli_shared_1.getNVueCompiler)(manifestJson);
+    if (nvueCompiler === 'uni-app') {
+        process.env.UNI_NVUE_COMPILER = 'uni-app';
+    }
+    else if (nvueCompiler === 'vue') {
+        process.env.UNI_NVUE_COMPILER = 'vue';
+    }
+    if ((0, uni_cli_shared_1.getNVueStyleCompiler)(manifestJson) === 'uni-app') {
+        process.env.UNI_NVUE_STYLE_COMPILER = 'uni-app';
+    }
+    if ((0, uni_cli_shared_1.getAppCodeSpliting)(manifestJson)) {
+        process.env.UNI_APP_CODE_SPLITING = 'true';
+    }
+}
+exports.initNVueEnv = initNVueEnv;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/server.d.ts

@@ -0,0 +1,4 @@
+import type { ServerOptions, ViteDevServer } from 'vite';
+import type { CliOptions } from '.';
+export declare function createServer(options: CliOptions & ServerOptions): Promise<ViteDevServer>;
+export declare function createSSRServer(options: CliOptions & ServerOptions): Promise<ViteDevServer>;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/server.js

@@ -0,0 +1,229 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSRServer = exports.createServer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const utils_1 = require("./utils");
+function createLogger(level, options) {
+    return Promise.resolve().then(() => __importStar(require('vite'))).then(({ createLogger }) => createLogger(level, options));
+}
+function createViteServer(inlineConfig) {
+    return Promise.resolve().then(() => __importStar(require('vite'))).then(({ createServer }) => createServer(inlineConfig));
+}
+async function createServer(options) {
+    const server = await createViteServer((0, utils_1.addConfigFile)({
+        root: process.env.VITE_ROOT_DIR,
+        configFile: options.config,
+        base: options.base,
+        mode: options.mode,
+        logLevel: options.logLevel || 'info',
+        clearScreen: options.clearScreen,
+        server: (0, utils_1.cleanOptions)(options),
+    }));
+    await server.listen();
+    const logger = server.config.logger;
+    logger.info(picocolors_1.default.cyan(`\n  vite v${require('vite/package.json').version}`) +
+        picocolors_1.default.green(` dev server running at:\n`), {
+        clear: !server.config.logger.hasWarned,
+    });
+    server.printUrls();
+    // printUrls 会在 nextTick 中输出
+    process.nextTick(() => (0, utils_1.printStartupDuration)(logger));
+    return server;
+}
+exports.createServer = createServer;
+async function createSSRServer(options) {
+    // 延迟加载
+    const app = (await Promise.resolve().then(() => __importStar(require('express')))).default();
+    /**
+     * @type {import('vite').ViteDevServer}
+     */
+    const vite = await createViteServer((0, utils_1.addConfigFile)({
+        // custom: don't include HTML middlewares
+        appType: 'custom',
+        root: process.env.VITE_ROOT_DIR,
+        configFile: options.config,
+        base: options.base,
+        mode: options.mode,
+        logLevel: options.logLevel || 'info',
+        clearScreen: options.clearScreen,
+        server: {
+            middlewareMode: true,
+            watch: {
+                // During tests we edit the files too fast and sometimes chokidar
+                // misses change events, so enforce polling for consistency
+                usePolling: true,
+                interval: 100,
+            },
+        },
+    }));
+    // use vite's connect instance as middleware
+    app.use(vite.middlewares);
+    app.use('*', async (req, res) => {
+        try {
+            const manifestJson = (0, uni_cli_shared_1.parseManifestJson)(process.env.UNI_INPUT_DIR);
+            const h5 = (0, uni_cli_shared_1.getPlatformManifestJson)(manifestJson, 'h5');
+            const base = (h5 && h5.router && h5.router.base) || '';
+            const url = req.originalUrl.replace(base, '');
+            const template = await vite.transformIndexHtml(url, fs_1.default.readFileSync(path_1.default.resolve(process.env.VITE_ROOT_DIR, 'index.html'), 'utf-8'));
+            const render = (await vite.ssrLoadModule(path_1.default.resolve(process.env.UNI_INPUT_DIR, 'entry-server.js'))).render;
+            const { title, headMeta, preloadLinks, appHtml, appContext } = await render(url);
+            const icon = template.includes('rel="icon"')
+                ? ''
+                : '<link rel="icon" href="data:," />\n';
+            const html = template
+                .replace(/<title>(.*?)<\/title>/, `${icon}<title>${title}</title>`)
+                .replace(`<!--head-meta-->`, headMeta)
+                .replace(`<!--preload-links-->`, preloadLinks)
+                .replace(`<!--app-html-->`, appHtml)
+                .replace(`<!--app-context-->`, appContext);
+            res.status(200).set({ 'Content-Type': 'text/html' }).end(html);
+        }
+        catch (e) {
+            vite && vite.ssrFixStacktrace(e);
+            res.status(500).end(e.stack);
+        }
+    });
+    const logger = await createLogger(options.logLevel);
+    const serverOptions = vite.config.server || {};
+    let port = options.port || serverOptions.port || 5173;
+    let hostname;
+    if (options.host === 'localhost') {
+        // Use a secure default
+        hostname = '127.0.0.1';
+    }
+    else if (options.host === undefined || options.host === true) {
+        // probably passed --host in the CLI, without arguments
+        hostname = undefined; // undefined typically means 0.0.0.0 or :: (listen on all IPs)
+    }
+    else {
+        hostname = options.host;
+    }
+    return new Promise((resolve, reject) => {
+        const onSuccess = () => {
+            printHttpServerUrls(server, vite.config);
+            process.nextTick(() => (0, utils_1.printStartupDuration)(logger));
+            resolve(vite);
+        };
+        const onError = (e) => {
+            if (e.code === 'EADDRINUSE') {
+                if (options.strictPort) {
+                    server.off('error', onError);
+                    reject(new Error(`Port ${port} is already in use`));
+                }
+                else {
+                    logger.info(`Port ${port} is in use, trying another one...`);
+                    server = app.listen(++port, hostname, onSuccess).on('error', onError);
+                }
+            }
+            else {
+                server.off('error', onError);
+                reject(e);
+            }
+        };
+        let server = app.listen(port, hostname, onSuccess).on('error', onError);
+    });
+}
+exports.createSSRServer = createSSRServer;
+function printHttpServerUrls(server, config) {
+    printCommonServerUrls(server, config.server, config);
+}
+function printCommonServerUrls(server, options, config) {
+    const address = server.address();
+    const isAddressInfo = (x) => x?.address;
+    if (isAddressInfo(address)) {
+        const hostname = resolveHostname(options.host);
+        const protocol = options.https ? 'https' : 'http';
+        printServerUrls(hostname, protocol, address.port, config.base, config.logger.info);
+    }
+}
+function printServerUrls(hostname, protocol, port, base, info) {
+    if (hostname.host === '127.0.0.1') {
+        const url = `${protocol}://${hostname.name}:${picocolors_1.default.bold(port)}${base}`;
+        info(`  - Local: ${picocolors_1.default.cyan(url)}`);
+        if (hostname.name !== '127.0.0.1') {
+            info(`  - Network: ${picocolors_1.default.dim('use `--host` to expose')}`);
+        }
+    }
+    else {
+        Object.values(os_1.default.networkInterfaces())
+            .flatMap((nInterface) => nInterface ?? [])
+            .filter((detail) => detail &&
+            detail.address &&
+            // Node < v18
+            ((typeof detail.family === 'string' && detail.family === 'IPv4') ||
+                // Node >= v18
+                // @ts-expect-error
+                (typeof detail.family === 'number' && detail.family === 4)))
+            .map((detail) => {
+            const type = detail.address.includes('127.0.0.1')
+                ? '  - Local:   '
+                : '  * Network: ';
+            const host = detail.address.replace('127.0.0.1', hostname.name);
+            const url = `${protocol}://${host}:${picocolors_1.default.bold(port)}${base}`;
+            return `${type} ${picocolors_1.default.cyan(url)}`;
+        })
+            .sort((msg1) => {
+            return msg1.indexOf('- Local') > -1 ? -1 : 1;
+        })
+            .forEach((msg, index, arr) => {
+            if (arr.length - 1 === index) {
+                info(msg.replace('* Network', '- Network'));
+            }
+            else {
+                info(msg);
+            }
+        });
+    }
+}
+function resolveHostname(optionsHost) {
+    let host;
+    if (optionsHost === undefined || optionsHost === false) {
+        // Use a secure default
+        host = '127.0.0.1';
+    }
+    else if (optionsHost === true) {
+        // If passed --host in the CLI without arguments
+        host = undefined; // undefined typically means 0.0.0.0 or :: (listen on all IPs)
+    }
+    else {
+        host = optionsHost;
+    }
+    // Set host name to localhost when possible, unless the user explicitly asked for '127.0.0.1'
+    const name = (optionsHost !== '127.0.0.1' && host === '127.0.0.1') ||
+        host === '0.0.0.0' ||
+        host === '::' ||
+        host === undefined
+        ? 'localhost'
+        : host;
+    return { host, name };
+}

node_modules/@dcloudio/vite-plugin-uni/dist/cli/utils.d.ts

@@ -0,0 +1,33 @@
+import type { InlineConfig, Logger } from 'vite';
+import type { CliOptions } from '.';
+export declare const PLATFORMS: string[];
+export type PLATFORM = 'app' | 'mp-alipay' | 'mp-baidu' | 'mp-kuaishou' | 'mp-lark' | 'mp-qq' | 'mp-toutiao' | 'mp-weixin' | 'mp-xhs' | 'quickapp-webview' | 'quickapp-webview-huawei' | 'quickapp-webview-union';
+export declare function addConfigFile(inlineConfig: InlineConfig): InlineConfig;
+export declare function initEnv(type: 'unknown' | 'dev' | 'build', options: CliOptions): void;
+export declare function cleanOptions(options: CliOptions): {
+    '--'?: string[] | undefined;
+    c?: string | boolean | undefined;
+    config?: string | undefined;
+    platform?: string | undefined;
+    p?: string | undefined;
+    ssr?: boolean | undefined;
+    base?: string | undefined;
+    debug?: string | boolean | undefined;
+    d?: string | boolean | undefined;
+    filter?: string | undefined;
+    f?: string | undefined;
+    logLevel?: import("vite").LogLevel | undefined;
+    l?: import("vite").LogLevel | undefined;
+    m?: string | undefined;
+    mode?: string | undefined;
+    clearScreen?: boolean | undefined;
+    autoHost?: string | undefined;
+    autoPort?: number | undefined;
+    devtools?: boolean | undefined;
+    devtoolsHost?: string | undefined;
+    devtoolsPort?: number | undefined;
+    subpackage?: string | undefined;
+    plugin?: boolean | undefined;
+};
+export declare function printStartupDuration(logger: Logger, whitespace?: boolean): void;
+export declare function showRunPrompt(platform: PLATFORM): void;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/utils.js

@@ -0,0 +1,367 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showRunPrompt = exports.printStartupDuration = exports.cleanOptions = exports.initEnv = exports.addConfigFile = exports.PLATFORMS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const perf_hooks_1 = require("perf_hooks");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const nvue_1 = require("./nvue");
+const uvue_1 = require("./uvue");
+// uni -p
+exports.PLATFORMS = [
+    'app',
+    'h5',
+    'mp-alipay',
+    'mp-baidu',
+    'mp-kuaishou',
+    'mp-lark',
+    'mp-qq',
+    'mp-toutiao',
+    'mp-weixin',
+    'mp-xhs',
+    'quickapp-webview',
+    'quickapp-webview-huawei',
+    'quickapp-webview-union',
+];
+function resolveConfigFile() {
+    const extname = ['.js', '.ts', '.mjs', '.mts'].find((ext) => {
+        return fs_1.default.existsSync(path_1.default.resolve(process.env.UNI_INPUT_DIR, 'vite.config' + ext));
+    });
+    if (extname) {
+        return path_1.default.resolve(process.env.UNI_INPUT_DIR, 'vite.config' + extname);
+    }
+    return path_1.default.resolve(process.env.UNI_CLI_CONTEXT, 'vite.config.js');
+}
+function addConfigFile(inlineConfig) {
+    if ((0, uni_cli_shared_1.isInHBuilderX)()) {
+        inlineConfig.configFile = resolveConfigFile();
+    }
+    return inlineConfig;
+}
+exports.addConfigFile = addConfigFile;
+let initialized = false;
+function initEnv(type, options) {
+    if (initialized) {
+        return;
+    }
+    initialized = true;
+    if (options.platform === 'mp-360') {
+        console.error(uni_cli_shared_1.M['mp.360.unsupported']);
+        process.exit(0);
+    }
+    if (options.platform === 'web') {
+        options.platform = 'h5';
+    }
+    if (options.plugin) {
+        process.env.UNI_MP_PLUGIN = 'true';
+    }
+    // TODO 需要识别 mode
+    if (type === 'dev') {
+        process.env.NODE_ENV = 'development';
+    }
+    else if (type === 'build') {
+        if (options.watch) {
+            process.env.NODE_ENV = 'development';
+        }
+        else {
+            if (!(0, uni_cli_shared_1.isNormalCompileTarget)()) {
+                if (!process.env.NODE_ENV) {
+                    process.env.NODE_ENV = 'production';
+                }
+            }
+            else {
+                process.env.NODE_ENV = 'production';
+            }
+        }
+    }
+    if (!options.mode) {
+        options.mode = process.env.NODE_ENV;
+    }
+    // vite 会修改 NODE_ENV，存储在 UNI_NODE_ENV 中，稍后校正 NODE_ENV
+    process.env.UNI_NODE_ENV = process.env.VITE_USER_NODE_ENV =
+        process.env.NODE_ENV;
+    process.env.UNI_CLI_CONTEXT = (0, uni_cli_shared_1.isInHBuilderX)()
+        ? path_1.default.resolve(process.env.UNI_HBUILDERX_PLUGINS, 'uniapp-cli-vite')
+        : process.cwd();
+    // TODO 待优化
+    initUTSPlatform(options);
+    if (options.platform === 'quickapp-webview-huawei' ||
+        options.platform === 'quickapp-webview-union') {
+        process.env.UNI_SUB_PLATFORM = options.platform;
+        options.platform = 'quickapp-webview';
+    }
+    if ((0, uni_cli_shared_1.isInHBuilderX)()) {
+        process.env.VITE_ROOT_DIR =
+            process.env.VITE_ROOT_DIR || process.env.UNI_INPUT_DIR || process.cwd();
+    }
+    else {
+        process.env.VITE_ROOT_DIR = process.env.VITE_ROOT_DIR || process.cwd();
+    }
+    process.env.UNI_INPUT_DIR =
+        process.env.UNI_INPUT_DIR || path_1.default.resolve(process.cwd(), 'src');
+    initCustomScripts(options);
+    process.env.UNI_PLATFORM = options.platform;
+    if (process.env.UNI_PLATFORM === 'app-harmony') {
+        if (process.env.UNI_APP_HARMONY_PROJECT_PATH) {
+            // 先通过原始outputDir设置，因为下边会修改原始的outputDir到鸿蒙项目里，而这些临时目录不应该影响到鸿蒙项目
+            process.env.UNI_APP_X_TSC_DIR = path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../.tsc');
+            process.env.UNI_APP_X_UVUE_DIR = path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../.uvue');
+            const baseOutDir = path_1.default.basename(process.env.UNI_OUTPUT_DIR);
+            process.env.UNI_APP_X_CACHE_DIR =
+                process.env.UNI_APP_X_CACHE_DIR ||
+                    path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../cache/.' + baseOutDir);
+            process.env.UNI_APP_X_TSC_CACHE_DIR = path_1.default.resolve(process.env.UNI_APP_X_CACHE_DIR, `tsc`);
+            // 指定了鸿蒙项目根目录
+            process.env.UNI_OUTPUT_DIR = path_1.default.resolve(process.env.UNI_APP_HARMONY_PROJECT_PATH, `entry/src/main/resources/resfile/apps/HBuilder/www`);
+        }
+    }
+    const hasOutputDir = !!process.env.UNI_OUTPUT_DIR;
+    if (hasOutputDir) {
+        ;
+        options.outDir = process.env.UNI_OUTPUT_DIR;
+    }
+    else {
+        if (!options.outDir) {
+            ;
+            options.outDir = path_1.default.resolve(process.cwd(), 'dist', process.env.NODE_ENV === 'production' ? 'build' : 'dev', (0, uni_cli_shared_1.getPlatformDir)());
+        }
+        process.env.UNI_OUTPUT_DIR = options.outDir;
+    }
+    // 兼容 HBuilderX 旧参数
+    if (process.env.UNI_SUBPACKGE) {
+        options.subpackage = process.env.UNI_SUBPACKGE;
+    }
+    if (options.subpackage) {
+        process.env.UNI_SUBPACKAGE = options.subpackage;
+        if (!hasOutputDir) {
+            // 未指定，则自动补充
+            process.env.UNI_OUTPUT_DIR = options.outDir =
+                path_1.default.resolve(process.env.UNI_OUTPUT_DIR, options.subpackage);
+        }
+    }
+    const baseOutDir = path_1.default.basename(process.env.UNI_OUTPUT_DIR);
+    process.env.UNI_APP_X_CACHE_DIR =
+        process.env.UNI_APP_X_CACHE_DIR ||
+            path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../cache/.' + baseOutDir);
+    if ((0, uni_cli_shared_1.isNormalCompileTarget)()) {
+        process.env.HX_DEPENDENCIES_DIR =
+            process.env.HX_DEPENDENCIES_DIR ||
+                path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../hx/' + baseOutDir);
+    }
+    process.env.UNI_MODULES_ENCRYPT_CACHE_DIR = path_1.default.resolve(process.env.UNI_APP_X_CACHE_DIR, '.encrypt', process.env.NODE_ENV === 'development' ? 'dev' : 'build', process.env.UNI_UTS_PLATFORM);
+    // 默认开启 tsc
+    process.env.UNI_APP_X_TSC = 'true';
+    try {
+        // 部分模式下缺少manifest.json，比如内部编译ext-api时
+        const manifestJson = (0, uni_cli_shared_1.parseManifestJsonOnce)(process.env.UNI_INPUT_DIR);
+        // 留个开关
+        if (manifestJson['app']?.['utsCompilerVersion'] === 'v1' ||
+            manifestJson['app-plus']?.['utsCompilerVersion'] === 'v1') {
+            process.env.UNI_APP_X_TSC = 'false';
+        }
+    }
+    catch (e) { }
+    if (!process.env.UNI_APP_X_TSC_DIR) {
+        process.env.UNI_APP_X_TSC_DIR = path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../.tsc');
+    }
+    if (!process.env.UNI_APP_X_UVUE_DIR) {
+        process.env.UNI_APP_X_UVUE_DIR = path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../.uvue');
+    }
+    if (!process.env.UNI_APP_X_TSC_CACHE_DIR) {
+        process.env.UNI_APP_X_TSC_CACHE_DIR = path_1.default.resolve(process.env.UNI_APP_X_CACHE_DIR, `tsc`);
+    }
+    initAutomator(options);
+    initDevtools(options);
+    if (process.env.UNI_PLATFORM === 'app') {
+        (0, nvue_1.initNVueEnv)();
+    }
+    if (process.env.NODE_ENV === 'development') {
+        console.log(uni_cli_shared_1.M['dev.performance'] +
+            (process.env.UNI_PLATFORM.startsWith('mp-')
+                ? uni_cli_shared_1.M['dev.performance.mp']
+                : '') +
+            (process.env.UNI_PLATFORM === 'web' || process.env.UNI_PLATFORM === 'h5'
+                ? uni_cli_shared_1.M['dev.performance.web']
+                : ''));
+    }
+    if (options.sourcemap &&
+        process.env.NODE_ENV === 'production') {
+        process.env.SOURCEMAP = 'true';
+    }
+    (0, uni_cli_shared_1.initModulePaths)();
+    (0, uvue_1.initUVueEnv)();
+    const pkg = require('../../package.json');
+    process.env.UNI_COMPILER_VERSION =
+        process.env.UNI_COMPILER_VERSION ||
+            pkg['uni-app']?.['compilerVersion'] ||
+            '';
+    process.env.UNI_COMPILER_VERSION_TYPE = pkg.version.includes('alpha')
+        ? 'a'
+        : 'r';
+    (0, uni_cli_shared_1.initPreContext)(process.env.UNI_PLATFORM, process.env.UNI_CUSTOM_CONTEXT, process.env.UNI_UTS_PLATFORM, process.env.UNI_APP_X === 'true');
+    if (process.env.UNI_PLATFORM === 'app' ||
+        process.env.UNI_PLATFORM === 'web' ||
+        process.env.UNI_PLATFORM === 'h5') {
+        console.log(uni_cli_shared_1.M['app.compiler.version'].replace('{version}', process.env.UNI_COMPILER_VERSION +
+            `（${process.env.UNI_APP_X === 'true' ? 'uni-app x' : 'vue3'}）`));
+    }
+    console.log(uni_cli_shared_1.M['compiling']);
+}
+exports.initEnv = initEnv;
+function initUTSPlatform(options) {
+    if (options.platform === 'app-android') {
+        process.env.UNI_UTS_PLATFORM = 'app-android';
+        options.platform = 'app';
+    }
+    else if (options.platform === 'app-ios') {
+        process.env.UNI_UTS_PLATFORM = 'app-ios';
+        options.platform = 'app';
+    }
+    else {
+        // 运行时，可能传入了 UNI_APP_PLATFORM = 'android'|'ios'
+        if (process.env.UNI_APP_PLATFORM === 'android') {
+            process.env.UNI_UTS_PLATFORM = 'app-android';
+        }
+        if (process.env.UNI_APP_PLATFORM === 'ios') {
+            process.env.UNI_UTS_PLATFORM = 'app-ios';
+        }
+        if (options.platform === 'app-plus') {
+            options.platform = 'app';
+        }
+        if (options.platform === 'app') {
+            // app 平台未指定 UTS_PLATFORM 时，设置未 app，一般是发行模式
+            if (!process.env.UNI_UTS_PLATFORM) {
+                process.env.UNI_UTS_PLATFORM = 'app';
+            }
+        }
+    }
+    if (options.platform === 'h5') {
+        process.env.UNI_UTS_PLATFORM = 'web';
+    }
+    // 非 app 平台，自动补充 UNI_UTS_PLATFORM
+    // app 平台，必须主动传入
+    if (options.platform !== 'app') {
+        if (!process.env.UNI_UTS_PLATFORM) {
+            process.env.UNI_UTS_PLATFORM = options.platform;
+        }
+    }
+    process.env.UNI_UTS_TARGET_LANGUAGE = 'javascript';
+    if (process.env.UNI_UTS_PLATFORM === 'app-android') {
+        process.env.UNI_UTS_TARGET_LANGUAGE = 'kotlin';
+    }
+    else if (process.env.UNI_UTS_PLATFORM === 'app-ios') {
+        process.env.UNI_UTS_TARGET_LANGUAGE = 'swift';
+    }
+    else if (process.env.UNI_UTS_PLATFORM === 'app-harmony') {
+        process.env.UNI_UTS_TARGET_LANGUAGE = 'arkts';
+    }
+}
+function initDevtools({ devtools, devtoolsHost, devtoolsPort }) {
+    if (!devtools) {
+        return;
+    }
+    process.env.__VUE_PROD_DEVTOOLS__ = 'true';
+    if (devtoolsHost) {
+        process.env.__VUE_DEVTOOLS_HOST__ = devtoolsHost;
+    }
+    if (devtoolsPort) {
+        process.env.__VUE_DEVTOOLS_PORT__ = devtoolsPort + '';
+    }
+}
+function initAutomator({ autoHost, autoPort }) {
+    const hasAutoHostOrPort = autoHost || autoPort || process.env.UNI_AUTOMATOR_HOST;
+    // 发行分包,插件也不需要自动化测试
+    if (!hasAutoHostOrPort ||
+        process.env.UNI_SUBPACKAGE ||
+        process.env.UNI_MP_PLUGIN) {
+        return;
+    }
+    process.env.UNI_AUTOMATOR_WS_ENDPOINT =
+        'ws://' +
+            (autoHost || process.env.UNI_AUTOMATOR_HOST || resolveHostname()) +
+            ':' +
+            (autoPort || process.env.UNI_AUTOMATOR_PORT);
+}
+function resolveHostname() {
+    const interfaces = os_1.default.networkInterfaces();
+    const keys = Object.keys(interfaces);
+    for (const key of keys) {
+        const interfaceInfos = interfaces[key];
+        if (!interfaceInfos) {
+            continue;
+        }
+        for (const info of interfaceInfos) {
+            if ((info.family === 'IPv4' ||
+                /* Node >= v18 */ info.family === 4) &&
+                !info.address.includes('127.0.0.1')) {
+                return info.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+function cleanOptions(options) {
+    const ret = { ...options };
+    delete ret['--'];
+    delete ret.c;
+    delete ret.config;
+    delete ret.platform;
+    delete ret.p;
+    delete ret.ssr;
+    delete ret.base;
+    delete ret.debug;
+    delete ret.d;
+    delete ret.filter;
+    delete ret.f;
+    delete ret.logLevel;
+    delete ret.l;
+    delete ret.clearScreen;
+    delete ret.m;
+    delete ret.mode;
+    delete ret.autoHost;
+    delete ret.autoPort;
+    return ret;
+}
+exports.cleanOptions = cleanOptions;
+function printStartupDuration(logger, whitespace = true) {
+    if (global.__vite_start_time) {
+        const startupDuration = perf_hooks_1.performance.now() - global.__vite_start_time;
+        logger.info(`${whitespace ? `\n  ` : ''}${picocolors_1.default.cyan(`ready in ${Math.ceil(startupDuration)}ms.`)}\n`);
+    }
+}
+exports.printStartupDuration = printStartupDuration;
+function initCustomScripts(options) {
+    const custom = (0, uni_cli_shared_1.parseScripts)(process.env.UNI_SCRIPT || options.platform, // process.env.UNI_SCRIPT 是 HBuilderX 传递的
+    path_1.default.join(process.env.VITE_ROOT_DIR, 'package.json'));
+    if (!custom) {
+        return;
+    }
+    options.platform = custom.platform;
+    process.env.UNI_CUSTOM_SCRIPT = custom.name;
+    process.env.UNI_CUSTOM_DEFINE = JSON.stringify(custom.define);
+    process.env.UNI_CUSTOM_CONTEXT = JSON.stringify(custom.context);
+}
+function showRunPrompt(platform) {
+    if (!(0, uni_cli_shared_1.isInHBuilderX)()) {
+        const devtools = getPlatformDevtools(getOriginalPlatform(platform));
+        const outputDir = path_1.default.relative(process.env.UNI_CLI_CONTEXT, process.env.UNI_OUTPUT_DIR);
+        (0, uni_cli_shared_1.output)('log', `${uni_cli_shared_1.M['prompt.run.message']
+            .replace('{devtools}', uni_cli_shared_1.M[devtools])
+            .replace('{outputDir}', picocolors_1.default.cyan(outputDir))}`);
+    }
+}
+exports.showRunPrompt = showRunPrompt;
+function getOriginalPlatform(platform) {
+    if (platform.startsWith('quickapp-webview') && process.env.UNI_SUB_PLATFORM) {
+        return process.env.UNI_SUB_PLATFORM;
+    }
+    return platform;
+}
+function getPlatformDevtools(platform) {
+    return `prompt.run.devtools.${platform}`;
+}

node_modules/@dcloudio/vite-plugin-uni/dist/cli/uvue.d.ts

@@ -0,0 +1,16 @@
+import { type BuildOptions, type ServerOptions } from 'vite';
+import type { RollupWatcher } from 'rollup';
+import type { CliOptions } from '.';
+export declare function initUVueEnv(): void;
+export declare function runUVueAndroidDev(options: CliOptions & ServerOptions): Promise<undefined>;
+export declare function runUVueAndroidBuild(options: CliOptions & BuildOptions): Promise<void>;
+/**
+ * 目前的简易实现逻辑
+ * node层：
+ *  1. 监听项目，生成资源到临时目录 .uts/android
+ *  2. uvue 文件，做解析，拆分生成 render.kt, css.kt, uts.uvue
+ *  3. static 文件，copy 到最终目录
+ *  4. uvue、vue、uts 文件发生变化，调用 uts 编译器
+ * @param options
+ */
+export declare function buildUVue(options: CliOptions): Promise<RollupWatcher | void>;

node_modules/@dcloudio/vite-plugin-uni/dist/cli/uvue.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUVue = exports.runUVueAndroidBuild = exports.runUVueAndroidDev = exports.initUVueEnv = void 0;
+const vite_1 = require("vite");
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const build_1 = require("./build");
+const utils_1 = require("./utils");
+const easycom_1 = require("../utils/easycom");
+const action_1 = require("./action");
+function initUVueEnv() {
+    // 直接指定了
+    if (process.env.UNI_APP_X === 'false') {
+        return;
+    }
+    // 没有手动指定时，才需要动态读取 manifest.json
+    if (process.env.UNI_APP_X !== 'true') {
+        const manifestJson = (0, uni_cli_shared_1.parseManifestJsonOnce)(process.env.UNI_INPUT_DIR);
+        if (!(0, shared_1.hasOwn)(manifestJson, 'uni-app-x')) {
+            return;
+        }
+        process.env.UNI_APP_X = 'true';
+        if (manifestJson['uni-app-x']?.singleThread === false) {
+            process.env.UNI_APP_X_SINGLE_THREAD = 'false';
+        }
+    }
+    if (process.env.UNI_PLATFORM === 'app') {
+        process.env.UNI_APP_X_UVUE_SCRIPT_ENGINE = 'native';
+        // 如果是app-ios，目前强制使用js引擎
+        if (process.env.UNI_UTS_PLATFORM === 'app-ios') {
+            process.env.UNI_APP_X_UVUE_SCRIPT_ENGINE = 'js';
+        }
+    }
+}
+exports.initUVueEnv = initUVueEnv;
+async function runUVueAndroidDev(options) {
+    if (options.platform !== 'app') {
+        (0, uni_cli_shared_1.output)('error', uni_cli_shared_1.M['uvue.unsupported'].replace('{platform}', options.platform));
+        return process.exit(0);
+    }
+    (0, easycom_1.initEasycom)();
+    const watcher = (await buildUVue(options));
+    let isFirstStart = true;
+    let isFirstEnd = true;
+    watcher.on('event', async (event) => {
+        if (event.code === 'BUNDLE_START') {
+            if (isFirstStart) {
+                isFirstStart = false;
+                return;
+            }
+            (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.start']);
+            // 重置一下，uts编译报错会导致下一次开始差量编译紧接着上一次的差量编译，导致无法正常输出
+            (0, uni_cli_shared_1.resetOutput)('log');
+        }
+        else if (event.code === 'BUNDLE_END') {
+            event.result.close();
+            const dex = process.env.UNI_APP_UTS_CHANGED_FILES;
+            process.env.UNI_APP_UTS_CHANGED_FILES = '';
+            if (isFirstEnd) {
+                // 首次全量同步
+                isFirstEnd = false;
+                (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end']);
+                (0, utils_1.printStartupDuration)((0, vite_1.createLogger)(options.logLevel), false);
+                await (0, action_1.stopProfiler)((message) => (0, vite_1.createLogger)(options.logLevel).info(message));
+                return;
+            }
+            if (dex) {
+                const files = JSON.parse(dex);
+                if (!files.length) {
+                    // 本次无变动
+                    return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['uvue.dev.watching.end.empty']);
+                }
+                return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end.files'].replace('{files}', JSON.stringify(files)));
+            }
+            return (0, uni_cli_shared_1.output)('log', uni_cli_shared_1.M['dev.watching.end']);
+        }
+    });
+}
+exports.runUVueAndroidDev = runUVueAndroidDev;
+async function runUVueAndroidBuild(options) {
+    try {
+        (0, uni_cli_shared_1.initEasycomsOnce)(process.env.UNI_INPUT_DIR, {
+            dirs: (0, uni_cli_shared_1.resolveComponentsLibDirs)(),
+            platform: process.env.UNI_PLATFORM,
+            isX: true,
+        });
+        await buildUVue(options);
+        await (0, action_1.stopProfiler)((message) => (0, vite_1.createLogger)(options.logLevel).info(message));
+        console.log(uni_cli_shared_1.M['build.done']);
+        // 开发者可能用了三方插件，三方插件有可能阻止退出，导致HBuilderX打包状态识别不正确
+        if ((0, uni_cli_shared_1.isInHBuilderX)()) {
+            process.exit(0);
+        }
+    }
+    catch (e) {
+        console.error(e.message || e);
+        console.error(`Build failed with errors.`);
+        process.exit(1);
+    }
+}
+exports.runUVueAndroidBuild = runUVueAndroidBuild;
+/**
+ * 目前的简易实现逻辑
+ * node层：
+ *  1. 监听项目，生成资源到临时目录 .uts/android
+ *  2. uvue 文件，做解析，拆分生成 render.kt, css.kt, uts.uvue
+ *  3. static 文件，copy 到最终目录
+ *  4. uvue、vue、uts 文件发生变化，调用 uts 编译器
+ * @param options
+ */
+async function buildUVue(options) {
+    return (0, build_1.buildByVite)((0, utils_1.addConfigFile)((0, shared_1.extend)({ nvueAppService: true, uvue: true }, (0, build_1.initBuildOptions)(options, (0, utils_1.cleanOptions)(options)))));
+}
+exports.buildUVue = buildUVue;

node_modules/@dcloudio/vite-plugin-uni/dist/config/build.d.ts

@@ -0,0 +1,3 @@
+import type { UserConfig } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function createBuild(options: VitePluginUniResolvedOptions, config: UserConfig): UserConfig['build'];

node_modules/@dcloudio/vite-plugin-uni/dist/config/build.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuild = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const shared_1 = require("@vue/shared");
+function createBuild(options, config) {
+    (0, uni_cli_shared_1.initEasycomsOnce)(options.inputDir, {
+        dirs: (0, uni_cli_shared_1.resolveComponentsLibDirs)(),
+        platform: process.env.UNI_PLATFORM,
+        isX: process.env.UNI_APP_X === 'true',
+    });
+    const rollupOutputOption = config.build?.rollupOptions?.output;
+    const sourcemap = process.env.SOURCEMAP === 'true' ? 'hidden' : config.build?.sourcemap;
+    return {
+        sourcemap,
+        cssTarget: uni_cli_shared_1.cssTarget,
+        chunkSizeWarningLimit: 100000000,
+        minify: config.build && (0, shared_1.hasOwn)(config.build, 'minify')
+            ? config.build.minify
+            : process.env.NODE_ENV === 'production'
+                ? 'terser'
+                : false,
+        rollupOptions: {
+            onwarn(warning, warn) {
+                if (warning.code === 'UNUSED_EXTERNAL_IMPORT') {
+                    const { message } = warning;
+                    // ignore
+                    if (message.includes('"vue"') ||
+                        message.includes('"resolveComponent"') ||
+                        message.includes('"@dcloudio/uni-h5"')) {
+                        return;
+                    }
+                }
+                warn(warning);
+            },
+            output: {
+                sourcemapExcludeSources: !(0, shared_1.isArray)(rollupOutputOption) &&
+                    rollupOutputOption?.sourcemapExcludeSources === false
+                    ? false
+                    : process.env.SOURCEMAP === 'true',
+            },
+        },
+    };
+}
+exports.createBuild = createBuild;

node_modules/@dcloudio/vite-plugin-uni/dist/config/css.d.ts

@@ -0,0 +1,3 @@
+import type { UserConfig } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function createCss(options: VitePluginUniResolvedOptions, config: UserConfig): UserConfig['css'];

node_modules/@dcloudio/vite-plugin-uni/dist/config/css.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCss = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function resolveAdditionalData(inputDir, config) {
+    const uniScssFile = path_1.default.resolve(inputDir, 'uni.scss');
+    const userAdditionalData = config.css?.preprocessorOptions?.scss?.additionalData || '';
+    if (!fs_extra_1.default.existsSync(uniScssFile)) {
+        return userAdditionalData;
+    }
+    let content = fs_extra_1.default.readFileSync(uniScssFile, 'utf8');
+    if (content.includes('#endif')) {
+        content = (0, uni_cli_shared_1.preCss)(content);
+    }
+    return content + '\n' + userAdditionalData;
+}
+function createCss(options, config) {
+    return {
+        preprocessorOptions: {
+            scss: {
+                charset: false,
+                additionalData: resolveAdditionalData(options.inputDir, config),
+            },
+        },
+    };
+}
+exports.createCss = createCss;

node_modules/@dcloudio/vite-plugin-uni/dist/config/define.d.ts

@@ -0,0 +1,3 @@
+import type { UserConfig } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function createDefine(_: VitePluginUniResolvedOptions): UserConfig['define'];

node_modules/@dcloudio/vite-plugin-uni/dist/config/define.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefine = void 0;
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function createDefine(_) {
+    return (0, shared_1.extend)({
+        __VUE_I18N_FULL_INSTALL__: true,
+        __VUE_I18N_LEGACY_API__: true,
+        __VUE_I18N_PROD_DEVTOOLS__: false,
+        __INTLIFY_PROD_DEVTOOLS__: false,
+    }, (0, uni_cli_shared_1.initDefine)());
+}
+exports.createDefine = createDefine;

node_modules/@dcloudio/vite-plugin-uni/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function createConfig(options: VitePluginUniResolvedOptions, _uniPlugins: Plugin[]): Plugin['config'];

node_modules/@dcloudio/vite-plugin-uni/dist/config/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const css_1 = require("./css");
+const resolve_1 = require("./resolve");
+const build_1 = require("./build");
+const optimizeDeps_1 = require("./optimizeDeps");
+const define_1 = require("./define");
+function createConfig(options, _uniPlugins) {
+    return (config, env) => {
+        options.command = env.command;
+        let base = config.base;
+        if (!base) {
+            const manifestJson = (0, uni_cli_shared_1.parseManifestJsonOnce)(options.inputDir);
+            const h5 = (0, uni_cli_shared_1.getPlatformManifestJson)(manifestJson, 'h5');
+            base = (h5 && h5.router && h5.router.base) || '';
+        }
+        if (!base) {
+            base = '/';
+        }
+        options.base = base;
+        const pluginConfig = {
+            base: process.env.UNI_H5_BASE || base,
+            root: process.env.VITE_ROOT_DIR,
+            // TODO 临时设置为__static__,屏蔽警告：https://github.com/vitejs/vite/blob/824d042535033a5c3d7006978c0d05c201cd1c25/packages/vite/src/node/server/middlewares/transform.ts#L125
+            publicDir: config.publicDir || '__static__',
+            define: (0, define_1.createDefine)(options),
+            resolve: (0, resolve_1.createResolve)(options, config),
+            logLevel: config.logLevel || 'warn', // 默认使用 warn 等级，因为 info 等级vite:report 会输出文件列表等信息
+            optimizeDeps: (0, optimizeDeps_1.createOptimizeDeps)(options),
+            build: (0, build_1.createBuild)(options, config),
+            css: (0, css_1.createCss)(options, config),
+            esbuild: {
+                include: /\.(tsx?|jsx|uts)$/,
+                exclude: /\.js$/,
+                loader: 'ts',
+            },
+        };
+        if ((0, uni_cli_shared_1.isInHBuilderX)()) {
+            pluginConfig.cacheDir = path_1.default.resolve(process.env.UNI_OUTPUT_DIR, '../../cache/.vite');
+        }
+        return pluginConfig;
+    };
+}
+exports.createConfig = createConfig;

node_modules/@dcloudio/vite-plugin-uni/dist/config/optimizeDeps.d.ts

@@ -0,0 +1,3 @@
+import type { UserConfig } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function createOptimizeDeps(_options: VitePluginUniResolvedOptions): UserConfig['optimizeDeps'];

node_modules/@dcloudio/vite-plugin-uni/dist/config/optimizeDeps.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOptimizeDeps = void 0;
+function createOptimizeDeps(_options) {
+    return {
+        exclude: [
+            'vue',
+            'vuex',
+            'vue-i18n',
+            'vue-router',
+            '@dcloudio/uni-app',
+            '@dcloudio/uni-components',
+            '@dcloudio/uni-i18n',
+            '@dcloudio/uni-shared',
+            '@dcloudio/uni-stacktracey',
+            'pinia',
+        ],
+    };
+}
+exports.createOptimizeDeps = createOptimizeDeps;

node_modules/@dcloudio/vite-plugin-uni/dist/config/resolve.d.ts

@@ -0,0 +1,4 @@
+import type { ResolverFunction, UserConfig } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare const customResolver: ResolverFunction;
+export declare function createResolve(options: VitePluginUniResolvedOptions, _config: UserConfig): UserConfig['resolve'];

node_modules/@dcloudio/vite-plugin-uni/dist/config/resolve.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResolve = exports.customResolver = void 0;
+const path_1 = __importDefault(require("path"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function resolveUTSModuleProxyFile(id, importer) {
+    const file = (0, uni_cli_shared_1.resolveUTSAppModule)(process.env.UNI_UTS_PLATFORM, id, importer);
+    if (file) {
+        // app-js 会返回完整路径，不需要 uts-proxy
+        if (file.endsWith('.uts')) {
+            return file;
+        }
+        return file + '?uts-proxy';
+    }
+}
+const customResolver = (updatedId, importer) => {
+    updatedId = updatedId.split('?')[0];
+    const utsImporter = importer
+        ? path_1.default.dirname(importer)
+        : process.env.UNI_INPUT_DIR;
+    const utsModuleFile = process.env.UNI_PLATFORM === 'app' ||
+        process.env.UNI_PLATFORM === 'app-harmony'
+        ? resolveUTSModuleProxyFile(updatedId, utsImporter)
+        : (0, uni_cli_shared_1.resolveUTSModule)(updatedId, utsImporter);
+    if (utsModuleFile) {
+        return uni_cli_shared_1.isWindows ? (0, uni_cli_shared_1.normalizePath)(utsModuleFile) : utsModuleFile;
+    }
+    const resolveId = (0, uni_cli_shared_1.resolveEncryptUniModule)((0, uni_cli_shared_1.normalizePath)(updatedId), process.env.UNI_UTS_PLATFORM, process.env.UNI_APP_X === 'true');
+    if (resolveId) {
+        return resolveId;
+    }
+    if (uni_cli_shared_1.isWindows) {
+        return (0, uni_cli_shared_1.normalizePath)((0, uni_cli_shared_1.requireResolve)(updatedId, importer || process.env.UNI_INPUT_DIR));
+    }
+    return (0, uni_cli_shared_1.requireResolve)(updatedId, importer || process.env.UNI_INPUT_DIR);
+};
+exports.customResolver = customResolver;
+function createResolve(options, _config) {
+    const alias = [];
+    if ((0, uni_cli_shared_1.isNormalCompileTarget)()) {
+        // 加密组件内部使用的 vue export helper，需要重新映射回来
+        alias.push({
+            find: 'plugin-vue:export-helper',
+            replacement: '\0plugin-vue:export-helper',
+        });
+    }
+    return {
+        // 必须使用alias解析，插件定制的resolveId，不会被应用到css等预处理器中
+        alias: [
+            // because @rollup/plugin-alias' type doesn't allow function
+            // replacement, but its implementation does work with function values.
+            {
+                find: /^(~@|@)\/(.*)/,
+                replacement(_str, _$1, $2) {
+                    return (0, uni_cli_shared_1.normalizePath)(path_1.default.resolve(options.inputDir, $2));
+                },
+                customResolver: exports.customResolver,
+            },
+            ...alias,
+        ],
+        extensions: process.env.UNI_APP_X === 'true' ? uni_cli_shared_1.uni_app_x_extensions : uni_cli_shared_1.extensions,
+        preserveSymlinks: true,
+    };
+}
+exports.createResolve = createResolve;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/env.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedConfig } from 'vite';
+export declare function initEnv(config: ResolvedConfig): void;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/env.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initEnv = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function initEnv(config) {
+    if (!process.env.UNI_PLATFORM) {
+        process.env.UNI_PLATFORM = 'h5';
+    }
+    if (!process.env.UNI_CLI_CONTEXT) {
+        process.env.UNI_CLI_CONTEXT = process.cwd();
+    }
+    if (!process.env.UNI_INPUT_DIR) {
+        process.env.UNI_INPUT_DIR = path_1.default.resolve(config.root, 'src');
+    }
+    if (!process.env.UNI_OUTPUT_DIR) {
+        process.env.UNI_OUTPUT_DIR = path_1.default.resolve(config.root, config.build.outDir);
+    }
+    process.env.VUE_APP_DARK_MODE =
+        (0, uni_cli_shared_1.getPlatformManifestJsonOnce)().darkmode || false;
+    process.env.BROWSERSLIST_CONFIG = [
+        path_1.default.resolve(process.env.UNI_INPUT_DIR, '.browserslistrc'),
+        path_1.default.resolve(process.env.UNI_CLI_CONTEXT, 'package.json'),
+        path_1.default.resolve(process.cwd(), 'package.json'),
+    ].find((file) => fs_1.default.existsSync(file));
+}
+exports.initEnv = initEnv;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin, ResolvedConfig } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function createConfigResolved(options: VitePluginUniResolvedOptions): Plugin['configResolved'];
+export declare function initLogger({ logger, nvue, }: ResolvedConfig & {
+    nvue?: boolean;
+}): void;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initLogger = exports.createConfigResolved = void 0;
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const env_1 = require("./env");
+const options_1 = require("./options");
+const plugins_1 = require("./plugins");
+const resolve_1 = require("../config/resolve");
+function createConfigResolved(options) {
+    return (config) => {
+        // 如果是混合编译且是 nvue 时，部分逻辑无需执行
+        if (!(0, uni_cli_shared_1.isInHybridNVue)(config)) {
+            (0, env_1.initEnv)(config);
+        }
+        initLogger(config);
+        (0, options_1.initOptions)(options, config);
+        (0, plugins_1.initPlugins)(config, options);
+        if (!(0, uni_cli_shared_1.isInHybridNVue)(config)) {
+            initCheckUpdate();
+        }
+        if (uni_cli_shared_1.isWindows) {
+            // TODO 等 https://github.com/vitejs/vite/issues/3331 修复后，可以移除下列代码
+            // 2.8.0 已修复，但为了兼容旧版本，先不移除
+            const item = config.resolve.alias.find((item) => !(0, shared_1.isString)(item.find) ? item.find.test('@/') : false);
+            if (item) {
+                item.customResolver = resolve_1.customResolver;
+            }
+        }
+    };
+}
+exports.createConfigResolved = createConfigResolved;
+function initCheckUpdate() {
+    (0, uni_cli_shared_1.checkUpdate)({
+        inputDir: process.env.UNI_INPUT_DIR,
+        compilerVersion: process.env.UNI_COMPILER_VERSION,
+        versionType: process.env.UNI_COMPILER_VERSION_TYPE,
+    });
+}
+function initLogger({ logger, nvue, }) {
+    const { info, warn, error } = logger;
+    logger.info = (msg, opts) => {
+        msg = (0, uni_cli_shared_1.formatInfoMsg)(msg, (0, shared_1.extend)(opts || {}, { nvue }));
+        if (msg) {
+            return info(msg, opts);
+        }
+    };
+    logger.warn = (msg, opts) => {
+        msg = (0, uni_cli_shared_1.formatWarnMsg)(msg, opts);
+        if (msg) {
+            return warn(msg, opts);
+        }
+    };
+    logger.error = (msg, opts) => {
+        msg = (0, uni_cli_shared_1.formatErrMsg)(msg, opts);
+        if (msg) {
+            return error(msg, opts);
+        }
+    };
+}
+exports.initLogger = initLogger;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/options.d.ts

@@ -0,0 +1,3 @@
+import type { VitePluginUniResolvedOptions } from '..';
+import type { ResolvedConfig } from 'vite';
+export declare function initOptions(options: VitePluginUniResolvedOptions, config: ResolvedConfig): void;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/options.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initOptions = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function resolveBase() {
+    const manifest = (0, uni_cli_shared_1.parseManifestJsonOnce)(process.env.UNI_INPUT_DIR);
+    const webManifest = (0, uni_cli_shared_1.getPlatformManifestJson)(manifest, 'h5');
+    return (webManifest && webManifest.router && webManifest.router.base) || '/';
+}
+function initOptions(options, config) {
+    options.base = resolveBase();
+    options.outputDir = process.env.UNI_OUTPUT_DIR;
+    options.assetsDir = config.build.assetsDir;
+}
+exports.initOptions = initOptions;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/index.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPlugins = void 0;
+// import debug from 'debug'
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+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 UNI_H5_RE = /@dcloudio\/uni-h5/;
+function initPlugins(config, options) {
+    const uniPrePluginOptions = {
+        exclude: [...uni_cli_shared_1.COMMON_EXCLUDE, UNI_H5_RE],
+    };
+    const uniPreCssPluginOptions = {
+        exclude: [...uni_cli_shared_1.COMMON_EXCLUDE],
+    };
+    const plugins = config.plugins;
+    addPlugin(plugins, (0, resolveId_1.uniResolveIdPlugin)(options), 'vite:resolve', 'pre');
+    addPlugin(plugins, (0, uni_cli_shared_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, /\/@dcloudio\/uni-app/] }, options)), process.env.UNI_APP_X === 'true' ? 'uts' : 'vite:vue');
+    addPlugin(plugins, (0, json_1.uniJsonPlugin)(options), 'vite:json', 'pre');
+    addPlugin(plugins, (0, static_1.uniStaticPlugin)(options, config), 'vite:asset', 'pre');
+    if (process.env.UNI_HBUILDERX_PLUGINS && (0, uni_cli_shared_1.isNormalCompileTarget)()) {
+        try {
+            const { V } = (0, uni_cli_shared_1.requireUniHelpers)();
+            addPlugin(plugins, V({
+                dir: process.env.UNI_INPUT_DIR,
+                cacheDir: process.env.UNI_MODULES_ENCRYPT_CACHE_DIR,
+            }), 0, 'pre');
+        }
+        catch (e) { }
+    }
+    // if (process.env.DEBUG) {
+    // debugPlugin(plugins.length)
+    // debugPlugin(plugins.map((p) => (p as Plugin).name))
+    // }
+}
+exports.initPlugins = initPlugins;
+function addPlugin(plugins, plugin, index, type = 'post') {
+    if ((0, shared_1.isString)(index)) {
+        index = plugins.findIndex((plugin) => plugin.name === index);
+    }
+    return plugins.splice(index + (type === 'pre' ? 0 : 1), 0, plugin);
+}

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/json.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/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;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/preCss.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/preCss.js

@@ -0,0 +1,43 @@
+"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 = debug('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);
+    const isNVue = config.nvue;
+    const preJsFile = isNVue ? uni_cli_shared_1.preNVueJs : uni_cli_shared_1.preJs;
+    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: preJsFile(code),
+                map: (0, uni_cli_shared_1.withSourcemap)(config) ? this.getCombinedSourcemap() : null,
+            };
+        },
+    };
+}
+exports.uniPreCssPlugin = uniPreCssPlugin;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/preVue.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function uniPreVuePlugin(): Plugin;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/preVue.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniPreVuePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+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 (!(process.env.UNI_APP_X === 'true' ? uni_cli_shared_1.X_EXTNAME_VUE : 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)));
+            return {
+                code: (0, uni_cli_shared_1.parseVueCode)(code, isNVue).code, // 暂不提供sourcemap,意义不大
+                map: null,
+            };
+        },
+    };
+}
+exports.uniPreVuePlugin = uniPreVuePlugin;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/resolveId.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/resolveId.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.uniResolveIdPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+// const debugResolve = debug('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-cloud': 'dist/uni-cloud.es.js',
+    '@dcloudio/uni-i18n': 'dist/uni-i18n.es.js',
+    '@dcloudio/uni-shared': 'dist/uni-shared.es.js',
+    '@dcloudio/uni-stacktracey': 'dist/uni-stacktracey.es.js',
+    '@vue/shared': 'dist/shared.esm-bundler.js',
+    pinia: 'dist/pinia.mjs',
+};
+function uniResolveIdPlugin(options) {
+    const resolveCache = {};
+    return {
+        name: 'uni:resolve-id',
+        resolveId(id, importer) {
+            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])));
+            }
+            if (process.env.UNI_PLATFORM !== 'app') {
+                return (0, uni_cli_shared_1.resolveUTSModule)(id, importer ? path_1.default.dirname(importer) : process.env.UNI_INPUT_DIR);
+            }
+        },
+    };
+}
+exports.uniResolveIdPlugin = uniResolveIdPlugin;

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/ssr.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/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 magic_string_1 = __importDefault(require("magic-string"));
+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:ref',
+        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 magic_string_1.default(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();
+}

node_modules/@dcloudio/vite-plugin-uni/dist/configResolved/plugins/static.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/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);
+}

node_modules/@dcloudio/vite-plugin-uni/dist/index.d.ts

@@ -0,0 +1,27 @@
+import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite';
+import type { Options as VueOptions } from '@vitejs/plugin-vue';
+import type ViteLegacyPlugin from '@vitejs/plugin-legacy';
+import type { VueJSXPluginOptions } from '@vue/babel-plugin-jsx';
+import { type AutoImportOptions, type CopyOptions } from '@dcloudio/uni-cli-shared';
+export type ViteLegacyOptions = Parameters<typeof ViteLegacyPlugin>[0];
+export interface VitePluginUniOptions {
+    uvue?: boolean;
+    vueOptions?: VueOptions;
+    vueJsxOptions?: (VueJSXPluginOptions & {
+        babelPlugins?: any[];
+    }) | boolean;
+    viteLegacyOptions?: ViteLegacyOptions | false;
+    autoImportOptions?: AutoImportOptions;
+}
+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[];

node_modules/@dcloudio/vite-plugin-uni/dist/index.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBuild = exports.runDev = void 0;
+const fs_1 = __importDefault(require("fs"));
+const vite_1 = __importDefault(require("unplugin-auto-import/vite"));
+const plugin_vue_jsx_1 = __importDefault(require("@vitejs/plugin-vue-jsx"));
+const plugin_legacy_1 = __importDefault(require("@vitejs/plugin-legacy"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const config_1 = require("./config");
+const configResolved_1 = require("./configResolved");
+const copy_1 = require("./plugins/copy");
+const move_1 = require("./plugins/move");
+const utils_1 = require("./utils");
+const vue_1 = require("./vue");
+const utils_2 = require("./cli/utils");
+const plugins_1 = require("./uvue/plugins");
+// const debugUni = debug('uni:plugin')
+(0, uni_cli_shared_1.initModuleAlias)();
+var action_1 = require("./cli/action");
+Object.defineProperty(exports, "runDev", { enumerable: true, get: function () { return action_1.runDev; } });
+Object.defineProperty(exports, "runBuild", { enumerable: true, get: function () { return action_1.runBuild; } });
+let isFirst = true;
+function uniPlugin(rawOptions = {}) {
+    // 重写readFileSync，拦截.scss 等文件读取，实现条件编译，
+    (0, uni_cli_shared_1.rewriteScssReadFileSync)();
+    if ((0, uni_cli_shared_1.isInHBuilderX)()) {
+        (0, uni_cli_shared_1.rewriteExistsSyncHasRootFile)();
+    }
+    // 三方插件（如vitest）可能提供了自己的入口命令，需要补充 env 初始化逻辑
+    (0, utils_2.initEnv)('unknown', { platform: process.env.UNI_PLATFORM || 'h5' });
+    const options = {
+        ...rawOptions,
+        base: '/',
+        assetsDir: 'assets',
+        inputDir: '',
+        outputDir: '',
+        command: 'serve',
+        platform: 'h5',
+    };
+    options.platform = process.env.UNI_PLATFORM || 'h5';
+    options.inputDir = process.env.UNI_INPUT_DIR;
+    const plugins = process.env.UNI_APP_X === 'true' &&
+        process.env.UNI_UTS_PLATFORM === 'app-android'
+        ? createUVueAndroidPlugins(options)
+        : createPlugins(options);
+    // x 提供 auto import（非android、android自行处理）
+    if (process.env.UNI_APP_X === 'true' &&
+        process.env.UNI_UTS_PLATFORM !== 'app-android') {
+        plugins.unshift((0, vite_1.default)((0, uni_cli_shared_1.initAutoImportOptions)(process.env.UNI_UTS_PLATFORM, options.autoImportOptions || {})));
+    }
+    plugins.unshift((0, uni_cli_shared_1.uniJsonPlugin)());
+    return plugins;
+}
+exports.default = uniPlugin;
+function createPlugins(options) {
+    const plugins = [];
+    // uni x 需要插入到指定位置，此插件执行太早，又会引发 vue 文件的不支持，该插件是解析ast的，所以必须是合法的js或ts代码
+    if (process.env.UNI_APP_X === 'true' &&
+        // iOS 暂不使用该机制
+        process.env.UNI_UTS_PLATFORM !== 'app-ios') {
+        plugins.push((0, uni_cli_shared_1.uniUTSExtApiReplace)());
+    }
+    else {
+        const injects = (0, uni_cli_shared_1.parseUniExtApisOnce)(true, process.env.UNI_UTS_PLATFORM, process.env.UNI_UTS_TARGET_LANGUAGE);
+        if (Object.keys(injects).length) {
+            plugins.push((0, uni_cli_shared_1.uniViteInjectPlugin)('uni:ext-api-inject', injects));
+        }
+    }
+    // 仅限 h5
+    if (options.viteLegacyOptions && options.platform === 'h5') {
+        plugins.push(...(0, plugin_legacy_1.default)((0, vue_1.initPluginViteLegacyOptions)(options)));
+    }
+    const uniPlugins = (0, utils_1.initExtraPlugins)(process.env.UNI_CLI_CONTEXT || process.cwd(), process.env.UNI_PLATFORM || 'h5', options);
+    // debugUni(uniPlugins)
+    const uniPluginOptions = (0, utils_1.initPluginUniOptions)(uniPlugins);
+    options.copyOptions = uniPluginOptions.copyOptions;
+    if (options.vueJsxOptions) {
+        plugins.push((0, plugin_vue_jsx_1.default)((0, vue_1.initPluginVueJsxOptions)(options, uniPluginOptions.compilerOptions, uniPluginOptions.jsxOptions)));
+    }
+    plugins.push({
+        name: 'uni',
+        config: (0, config_1.createConfig)(options, uniPlugins),
+        configResolved: (0, configResolved_1.createConfigResolved)(options),
+    });
+    plugins.push(...uniPlugins);
+    // plugins.push(...initFixedEsbuildInitTSConfck(process.env.UNI_INPUT_DIR))
+    // 执行 build 命令时，vite 强制了 NODE_ENV
+    // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/build.ts#L405
+    // const config = await resolveConfig(inlineConfig, 'build', 'production')
+    // 在 @vitejs/plugin-vue 之前校正回来
+    if (process.env.UNI_NODE_ENV &&
+        process.env.UNI_NODE_ENV !== process.env.NODE_ENV) {
+        process.env.NODE_ENV = process.env.UNI_NODE_ENV;
+    }
+    plugins.unshift((0, vue_1.createPluginVueInstance)((0, vue_1.initPluginVueOptions)(options, uniPlugins, uniPluginOptions)));
+    let addCopyPlugin = false;
+    if (options.platform !== 'app') {
+        addCopyPlugin = true;
+    }
+    else {
+        // 仅在 vue 或 纯原生 App.vue 编译时做 copy
+        if (process.env.UNI_COMPILER !== 'nvue' ||
+            (process.env.UNI_RENDERER === 'native' &&
+                process.env.UNI_RENDERER_NATIVE === 'appService')) {
+            addCopyPlugin = true;
+        }
+        else if (process.env.UNI_APP_X === 'true') {
+            // app-ios
+            addCopyPlugin = true;
+        }
+    }
+    if (!(0, uni_cli_shared_1.isNormalCompileTarget)()) {
+        addCopyPlugin = false;
+    }
+    if (addCopyPlugin) {
+        plugins.push((0, copy_1.uniCopyPlugin)({
+            outputDir: process.env.UNI_OUTPUT_DIR,
+            copyOptions: options.copyOptions,
+        }));
+    }
+    if (process.env.SOURCEMAP === 'true') {
+        // 清空之前的 sourcemap 目录
+        const sourceMapPath = (0, uni_cli_shared_1.resolveSourceMapPath)();
+        if (isFirst) {
+            // 避免重复清空
+            isFirst = false;
+            if (fs_1.default.existsSync(sourceMapPath)) {
+                (0, uni_cli_shared_1.emptyDir)(sourceMapPath);
+            }
+            plugins.push((0, move_1.uniMovePlugin)({
+                apply: 'build',
+                enforce: 'post',
+                cwd: process.env.UNI_OUTPUT_DIR,
+                pattern: '**/*.js.map',
+                dest: sourceMapPath,
+            }));
+        }
+    }
+    (0, utils_1.rewriteCompilerSfcParse)();
+    return plugins;
+}
+function createUVueAndroidPlugins(options) {
+    const plugins = [];
+    options.uvue = true;
+    const uniPlugins = (0, utils_1.initExtraPlugins)(process.env.UNI_CLI_CONTEXT || process.cwd(), process.env.UNI_PLATFORM || 'h5', options);
+    // debugUni(uniPlugins)
+    const uniPluginOptions = (0, utils_1.initPluginUniOptions)(uniPlugins);
+    options.copyOptions = uniPluginOptions.copyOptions;
+    plugins.push((0, plugins_1.uniUVuePlugin)(options));
+    plugins.push(...uniPlugins);
+    // plugins.push(...initFixedEsbuildInitTSConfck(process.env.UNI_INPUT_DIR))
+    // 执行 build 命令时，vite 强制了 NODE_ENV
+    // https://github.com/vitejs/vite/blob/main/packages/vite/src/node/build.ts#L405
+    // const config = await resolveConfig(inlineConfig, 'build', 'production')
+    // 在 @vitejs/plugin-vue 之前校正回来
+    if (process.env.UNI_NODE_ENV &&
+        process.env.UNI_NODE_ENV !== process.env.NODE_ENV) {
+        process.env.NODE_ENV = process.env.UNI_NODE_ENV;
+    }
+    if ((0, uni_cli_shared_1.isNormalCompileTarget)()) {
+        plugins.push((0, copy_1.uniCopyPlugin)({
+            outputDir: process.env.UNI_OUTPUT_DIR,
+            copyOptions: options.copyOptions,
+        }));
+    }
+    return plugins;
+}

node_modules/@dcloudio/vite-plugin-uni/dist/plugins/copy.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function uniCopyPlugin({ outputDir, copyOptions, }: Pick<VitePluginUniResolvedOptions, 'outputDir' | 'copyOptions'>): Plugin;

node_modules/@dcloudio/vite-plugin-uni/dist/plugins/copy.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniCopyPlugin = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugCopy = (0, debug_1.default)('uni:copy');
+function uniCopyPlugin({ outputDir, copyOptions, }) {
+    const staticDir = uni_cli_shared_1.PUBLIC_DIR + '/**/*';
+    const uniModulesStaticDir = 'uni_modules/*/' + uni_cli_shared_1.PUBLIC_DIR + '/**/*';
+    const assets = [staticDir, uniModulesStaticDir];
+    const subpackages = (0, uni_cli_shared_1.parseSubpackagesRootOnce)(process.env.UNI_INPUT_DIR, process.env.UNI_PLATFORM);
+    subpackages.forEach((root) => {
+        assets.push((0, uni_cli_shared_1.normalizePath)(path_1.default.join(root, staticDir)));
+        assets.push((0, uni_cli_shared_1.normalizePath)(path_1.default.join(root, uniModulesStaticDir)));
+    });
+    copyOptions.assets.forEach((asset) => {
+        assets.push(asset);
+    });
+    const inputDir = (0, uni_cli_shared_1.normalizePath)(process.env.UNI_INPUT_DIR);
+    const platform = process.env.UNI_PLATFORM;
+    // 非当前平台 static 目录
+    const ignorePlatformStaticDirs = (0, uni_cli_shared_1.getPlatforms)()
+        .filter((p) => {
+        if (platform === 'app') {
+            if (process.env.UNI_APP_X === 'true') {
+                return p !== 'app';
+            }
+            return p !== 'app' && p !== 'app-plus';
+        }
+        else if (platform === 'h5' || platform === 'web') {
+            return p !== 'h5' && p !== 'web';
+        }
+        else if (platform.startsWith('app-')) {
+            return p !== 'app' && p !== platform;
+        }
+        return p !== platform;
+    })
+        // 在最后增加 / 是为了避免误判以 platform 开头的目录，比如 app-test
+        .map((p) => '/' + uni_cli_shared_1.PUBLIC_DIR + '/' + p + '/');
+    const targets = [
+        {
+            src: assets,
+            dest: outputDir,
+            watchOptions: {
+                ignored(path) {
+                    const normalizedPath = (0, uni_cli_shared_1.normalizePath)(path);
+                    if (ignorePlatformStaticDirs.find((dir) => 
+                    // dir都是以 / 结尾，所以这里也要以 / 结尾
+                    (normalizedPath + '/').includes(dir))) {
+                        return fs_1.default.statSync(normalizedPath).isDirectory();
+                    }
+                    // 应该是软链
+                    if (!normalizedPath.startsWith(inputDir)) {
+                        // 目前仅简单处理static
+                        if (normalizedPath.includes('/static/')) {
+                            return false;
+                        }
+                        return true;
+                    }
+                    return false;
+                },
+            },
+        },
+    ];
+    targets.push(...copyOptions.targets);
+    debugCopy(targets);
+    checkIgnoreStatic(ignorePlatformStaticDirs.map((dir) => dir.substring(1).split('/')));
+    return (0, uni_cli_shared_1.uniViteCopyPlugin)({
+        targets,
+    });
+}
+exports.uniCopyPlugin = uniCopyPlugin;
+let isIgnoreChecked = false;
+function checkIgnoreStatic(ignoreStatic) {
+    if (isIgnoreChecked) {
+        return;
+    }
+    isIgnoreChecked = true;
+    const existIgnore = new Set();
+    ignoreStatic.forEach((ignore) => {
+        const dir = path_1.default.resolve(process.env.UNI_INPUT_DIR, ...ignore);
+        if (fs_1.default.existsSync(dir)) {
+            existIgnore.add(ignore.join('/'));
+        }
+    });
+    if (existIgnore.size) {
+        console.log('已忽略静态资源目录：' +
+            [...existIgnore].join('、') +
+            '。详见：https://uniapp.dcloud.net.cn/tutorial/platform.html#static');
+    }
+}

node_modules/@dcloudio/vite-plugin-uni/dist/plugins/move.d.ts

@@ -0,0 +1,19 @@
+import type { Plugin } from 'vite';
+interface UniMovePluginOptions {
+    apply: Plugin['apply'];
+    enforce: Plugin['enforce'];
+    /**
+     * 原始根目录
+     */
+    cwd: string;
+    /**
+     * glob pattern 如：**\/*.js.mp)
+     */
+    pattern: string;
+    /**
+     * 目标目录
+     */
+    dest: string;
+}
+export declare function uniMovePlugin({ apply, enforce, cwd, pattern, dest, }: UniMovePluginOptions): Plugin;
+export {};

node_modules/@dcloudio/vite-plugin-uni/dist/plugins/move.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniMovePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+function uniMovePlugin({ apply, enforce, cwd, pattern, dest, }) {
+    return {
+        name: 'uni:move',
+        apply,
+        enforce,
+        async writeBundle() {
+            await Promise.all(fast_glob_1.default
+                .sync(pattern, {
+                cwd,
+            })
+                .map((filename) => {
+                return fs_extra_1.default.move(path_1.default.resolve(cwd, filename), path_1.default.resolve(dest, filename), {
+                    overwrite: true,
+                });
+            }));
+        },
+    };
+}
+exports.uniMovePlugin = uniMovePlugin;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/easycom.d.ts

@@ -0,0 +1,2 @@
+import type { FSWatcher } from 'chokidar';
+export declare const initEasycom: (watcher?: FSWatcher) => void;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/easycom.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initEasycom = void 0;
+const debug_1 = __importDefault(require("debug"));
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugEasycom = (0, debug_1.default)('uni:easycom');
+const initEasycom = (watcher) => {
+    const { filter, refresh, options } = (0, uni_cli_shared_1.initEasycomsOnce)(process.env.UNI_INPUT_DIR, {
+        dirs: (0, uni_cli_shared_1.resolveComponentsLibDirs)(),
+        platform: process.env.UNI_PLATFORM,
+        isX: process.env.UNI_APP_X === 'true',
+    });
+    if (!watcher) {
+        // build 模式，手动初始化 watcher
+        debugEasycom('initWatch', options.dirs);
+        watcher = uni_cli_shared_1.chokidar.watch(options.dirs, {
+            ignored: ['**/node_modules/**', '**/.git/**'],
+            ignoreInitial: true,
+            ignorePermissionErrors: true,
+            disableGlobbing: true,
+        });
+    }
+    const refreshEasycom = (0, uni_shared_1.debounce)(refresh, 100, { setTimeout, clearTimeout });
+    watcher.on('all', (eventName, path) => {
+        if (!['add', 'unlink'].includes(eventName)) {
+            return;
+        }
+        if (filter(path)) {
+            debugEasycom('watch', eventName, path);
+            refreshEasycom();
+        }
+    });
+};
+exports.initEasycom = initEasycom;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/filter.d.ts

@@ -0,0 +1 @@
+export declare function createPublicFileFilter(base?: string): (id: unknown) => boolean;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/filter.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPublicFileFilter = void 0;
+const path_1 = __importDefault(require("path"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function createPublicFileFilter(base = '/') {
+    const publicDir = (0, uni_cli_shared_1.normalizePath)(path_1.default.join(base, uni_cli_shared_1.PUBLIC_DIR + '/**/*'));
+    const uniModulesDir = (0, uni_cli_shared_1.normalizePath)(path_1.default.join(base, 'uni_modules/*/' + uni_cli_shared_1.PUBLIC_DIR + '/**/*'));
+    return (0, pluginutils_1.createFilter)([publicDir, uniModulesDir]);
+}
+exports.createPublicFileFilter = createPublicFileFilter;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './filter';
+export * from './plugin';
+export * from './polyfill';
+export * from './nvue';

node_modules/@dcloudio/vite-plugin-uni/dist/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+__exportStar(require("./filter"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./polyfill"), exports);
+__exportStar(require("./nvue"), exports);

node_modules/@dcloudio/vite-plugin-uni/dist/utils/nvue.d.ts

@@ -0,0 +1,5 @@
+/**
+ * nvue 需要移除 scoped
+ * @param nvuePages
+ */
+export declare function createNVueCompiler(): any;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/nvue.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNVueCompiler = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const shared_1 = require("@vue/shared");
+/**
+ * nvue 需要移除 scoped
+ * @param nvuePages
+ */
+function createNVueCompiler() {
+    const compileSfc = require((0, uni_cli_shared_1.resolveBuiltIn)('@vue/compiler-sfc'));
+    const { parse } = compileSfc;
+    return (0, shared_1.extend)({}, compileSfc, {
+        parse(source, options = {}) {
+            const result = parse(source, options);
+            result.descriptor.styles.forEach((style) => {
+                if (style.scoped) {
+                    delete style.scoped;
+                }
+            });
+            return result;
+        },
+    });
+}
+exports.createNVueCompiler = createNVueCompiler;

node_modules/@dcloudio/vite-plugin-uni/dist/utils/plugin.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from 'vite';
+import { type UniViteCopyPluginTarget, type UniVitePlugin } from '@dcloudio/uni-cli-shared';
+import type { TemplateCompiler } from '@vue/compiler-sfc';
+import type { VitePluginUniResolvedOptions } from '..';
+export declare function initPluginUniOptions(UniVitePlugins: UniVitePlugin[]): {
+    compiler?: TemplateCompiler;
+    copyOptions: {
+        assets: string[];
+        targets: UniViteCopyPluginTarget[];
+    };
+    transformEvent: Record<string, string>;
+    compilerOptions: Required<Required<UniVitePlugin>['uni']>['compilerOptions'];
+    jsxOptions: Required<Required<UniVitePlugin>['uni']>['jsxOptions'];
+    styleOptions: Required<Required<UniVitePlugin>['uni']>['styleOptions'];
+};
+export declare function initExtraPlugins(cliRoot: string, platform: UniApp.PLATFORM, options: VitePluginUniResolvedOptions): Plugin<any>[];

node_modules/@dcloudio/vite-plugin-uni/dist/utils/plugin.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initExtraPlugins = exports.initPluginUniOptions = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+function initPluginUniOptions(UniVitePlugins) {
+    const assets = [];
+    const targets = [];
+    const transformEvent = Object.create(null);
+    const compilerOptions = {};
+    const jsxOptions = {};
+    const styleOptions = {};
+    let compiler;
+    UniVitePlugins.forEach((plugin) => {
+        const { compiler: pluginTemplateCompiler, copyOptions: pluginCopyOptions, compilerOptions: pluginCompilerOptions, jsxOptions: pluginJsxOptions, styleOptions: pluginStyleOpitons, } = plugin.uni || {};
+        if (pluginTemplateCompiler) {
+            compiler = pluginTemplateCompiler;
+        }
+        if (pluginCompilerOptions) {
+            (0, shared_1.extend)(compilerOptions, pluginCompilerOptions);
+        }
+        if (pluginJsxOptions) {
+            (0, shared_1.extend)(jsxOptions, pluginJsxOptions);
+        }
+        if (pluginStyleOpitons) {
+            (0, shared_1.extend)(styleOptions, pluginStyleOpitons);
+        }
+        if (pluginCopyOptions) {
+            let copyOptions = pluginCopyOptions;
+            if ((0, shared_1.isFunction)(pluginCopyOptions)) {
+                copyOptions = pluginCopyOptions();
+            }
+            if (copyOptions.assets) {
+                assets.push(...copyOptions.assets);
+            }
+            if (copyOptions.targets) {
+                targets.push(...copyOptions.targets);
+            }
+        }
+    });
+    return {
+        compiler,
+        copyOptions: {
+            assets,
+            targets,
+        },
+        transformEvent,
+        compilerOptions,
+        jsxOptions,
+        styleOptions,
+    };
+}
+exports.initPluginUniOptions = initPluginUniOptions;
+function initExtraPlugins(cliRoot, platform, options) {
+    return initPlugins(cliRoot, process.env.UNI_COMPILE_TARGET === 'ext-api' &&
+        process.env.UNI_APP_NEXT_WORKSPACE
+        ? resolvePluginsByWorkSpace(process.env.UNI_APP_NEXT_WORKSPACE, platform, options.uvue)
+        : resolvePluginsByCliRoot(cliRoot, platform, options.uvue), options);
+}
+exports.initExtraPlugins = initExtraPlugins;
+function initPlugin(_cliRoot, { pluginPath, config: { main } }, options) {
+    let plugin = require(path_1.default.join(pluginPath, main || '/lib/uni.plugin.js'));
+    plugin = plugin.default || plugin;
+    if ((0, shared_1.isFunction)(plugin)) {
+        plugin = plugin(options);
+    }
+    return plugin;
+}
+function initPlugins(cliRoot, plugins, options) {
+    return plugins
+        .map((plugin) => initPlugin(cliRoot, plugin, options))
+        .flat()
+        .filter(Boolean)
+        .map((plugin) => {
+        if ((0, shared_1.isFunction)(plugin)) {
+            return plugin(options);
+        }
+        return plugin;
+    })
+        .flat();
+}
+function resolvePluginsByCliRoot(cliRoot, platform, uvue = false) {
+    const pkg = require(path_1.default.join(cliRoot, 'package.json'));
+    return resolvePlugins(Object.keys(pkg.devDependencies || {})
+        .concat(Object.keys(pkg.dependencies || {}))
+        .map((id) => {
+        try {
+            const pkgFileName = require.resolve(id + '/package.json', {
+                paths: [cliRoot],
+            });
+            const pkg = require(pkgFileName);
+            return {
+                ...pkg,
+                pluginPath: path_1.default.dirname(pkgFileName),
+            };
+        }
+        catch (e) { }
+    })
+        .filter(Boolean), platform, uvue);
+}
+function resolvePluginsByWorkSpace(workspaceFolder, platform, uvue = false) {
+    const pkgDirs = path_1.default.resolve(workspaceFolder, 'packages');
+    return resolvePlugins(fs_extra_1.default
+        .readdirSync(pkgDirs)
+        .map((dir) => {
+        const pluginPath = path_1.default.join(pkgDirs, dir);
+        const pkgFileName = path_1.default.join(pluginPath, 'package.json');
+        if (fs_extra_1.default.existsSync(pkgFileName)) {
+            return {
+                ...require(pkgFileName),
+                pluginPath,
+            };
+        }
+    })
+        .filter(Boolean), platform, uvue);
+}
+function resolvePlugins(pkgs, platform, uvue = false) {
+    return pkgs
+        .map((pkg) => {
+        try {
+            const config = pkg['uni-app'];
+            if (!config || !config.name) {
+                return;
+            }
+            const { apply } = config;
+            if ((0, shared_1.isArray)(apply)) {
+                // 注册所有平台
+                apply.forEach((p) => (0, uni_cli_shared_1.registerPlatform)(p));
+                if (!apply.includes(platform)) {
+                    return;
+                }
+            }
+            else if ((0, shared_1.isString)(apply)) {
+                if (!new RegExp(apply).test(platform)) {
+                    return;
+                }
+            }
+            // 插件必须支持 uvue
+            if (uvue && !config.uvue) {
+                return;
+            }
+            return {
+                id: pkg.name,
+                name: config.name,
+                pluginPath: pkg.pluginPath,
+                config,
+            };
+        }
+        catch (e) { }
+    })
+        .filter(Boolean);
+}

node_modules/@dcloudio/vite-plugin-uni/dist/utils/polyfill.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from 'vite';
+/**
+ * TODO 临时重写，解决 @vitejs/plugin-vue 的 Bug
+ */
+export declare function rewriteCompilerSfcParse(): void;
+/**
+ * 已废弃，交由 rewriteExistsSyncHasRootFile 实现，因为新的 vite 版本在 configResolved 中重写已经晚了
+ * 解决 HBuilderX 项目未包含 package.json 时，initTSConfck 可能导致查找过慢，或递归目录时权限不足报错
+ * 即：未包含 package.json 时，直接移除 initTSConfck 相关逻辑
+ * @param inputDir
+ * @returns
+ */
+export declare function initFixedEsbuildInitTSConfck(inputDir: string): Plugin[];

node_modules/@dcloudio/vite-plugin-uni/dist/utils/polyfill.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initFixedEsbuildInitTSConfck = exports.rewriteCompilerSfcParse = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const shared_1 = require("@vue/shared");
+/**
+ * TODO 临时重写，解决 @vitejs/plugin-vue 的 Bug
+ */
+function rewriteCompilerSfcParse() {
+    const compilerSfc = require((0, uni_cli_shared_1.resolveBuiltIn)('@vue/compiler-sfc'));
+    const { parse } = compilerSfc;
+    let extname_vue = process.env.UNI_APP_X === 'true' ? uni_cli_shared_1.X_EXTNAME_VUE : uni_cli_shared_1.EXTNAME_VUE;
+    compilerSfc.parse = (source, options) => {
+        if (options?.filename) {
+            const extname = path_1.default.extname(options.filename);
+            // wxs、filter、renderjs
+            if (extname && !extname_vue.includes(extname)) {
+                const tag = extname.slice(1);
+                source = `<${tag}>` + source + `</${tag}>`;
+            }
+        }
+        return parse(source, options);
+    };
+}
+exports.rewriteCompilerSfcParse = rewriteCompilerSfcParse;
+/**
+ * 已废弃，交由 rewriteExistsSyncHasRootFile 实现，因为新的 vite 版本在 configResolved 中重写已经晚了
+ * 解决 HBuilderX 项目未包含 package.json 时，initTSConfck 可能导致查找过慢，或递归目录时权限不足报错
+ * 即：未包含 package.json 时，直接移除 initTSConfck 相关逻辑
+ * @param inputDir
+ * @returns
+ */
+function initFixedEsbuildInitTSConfck(inputDir) {
+    if (!(0, uni_cli_shared_1.isInHBuilderX)()) {
+        return [];
+    }
+    if (fs_1.default.existsSync(path_1.default.resolve(inputDir, 'package.json'))) {
+        return [];
+    }
+    // 'vite:esbuild', 'vite:esbuild-transpile' initTSConfck
+    const existsSync = fs_1.default.existsSync;
+    // 根目录 lerna.json 路径
+    const lernaJsonPath = (0, uni_cli_shared_1.normalizePath)(path_1.default.resolve(inputDir, 'lerna.json'));
+    return [
+        {
+            name: 'uni:fixed-HBuilderX-initTSConfck-before',
+            enforce: 'pre',
+            configResolved() {
+                // 在 HBuilderX 项目中，缺少 package.json 时， 确保 searchForWorkspaceRoot 使用项目根目录， 否则 initTSConfck 会查找很费时，且可能访问目录权限报错
+                // https://github.com/vitejs/vite/blob/43b7b78b1834a4c7128d8a5d987f66a4defcbd93/packages/vite/src/node/plugins/esbuild.ts#L407
+                fs_1.default.existsSync = (p) => {
+                    if ((0, shared_1.isString)(p)) {
+                        // 访问根目录 lerna.json 时，直接返回 true
+                        // https://github.com/vitejs/vite/blob/43b7b78b1834a4c7128d8a5d987f66a4defcbd93/packages/vite/src/node/server/searchRoot.ts#L35
+                        if (p.endsWith('lerna.json') &&
+                            lernaJsonPath === (0, uni_cli_shared_1.normalizePath)(p)) {
+                            return true;
+                        }
+                    }
+                    return existsSync(p);
+                };
+            },
+        },
+    ];
+}
+exports.initFixedEsbuildInitTSConfck = initFixedEsbuildInitTSConfck;

node_modules/@dcloudio/vite-plugin-uni/dist/uvue/plugins/index.d.ts

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

node_modules/@dcloudio/vite-plugin-uni/dist/uvue/plugins/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniUVuePlugin = void 0;
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const define_1 = require("../../config/define");
+const resolve_1 = require("../../config/resolve");
+const css_1 = require("../../config/css");
+const configResolved_1 = require("../../configResolved");
+function uniUVuePlugin(options) {
+    return {
+        name: 'uni:uvue',
+        config(config, env) {
+            options.command = env.command;
+            let base = config.base;
+            if (!base) {
+                const manifestJson = (0, uni_cli_shared_1.parseManifestJsonOnce)(options.inputDir);
+                const h5 = (0, uni_cli_shared_1.getPlatformManifestJson)(manifestJson, 'h5');
+                base = (h5 && h5.router && h5.router.base) || '';
+            }
+            if (!base) {
+                base = '/';
+            }
+            options.base = base;
+            return {
+                base: process.env.UNI_H5_BASE || base,
+                root: process.env.VITE_ROOT_DIR,
+                // TODO 临时设置为__static__,屏蔽警告：https://github.com/vitejs/vite/blob/824d042535033a5c3d7006978c0d05c201cd1c25/packages/vite/src/node/server/middlewares/transform.ts#L125
+                publicDir: config.publicDir || '__static__',
+                define: (0, define_1.createDefine)(options),
+                resolve: (0, resolve_1.createResolve)(options, config),
+                logLevel: config.logLevel || 'warn', // 默认使用 warn 等级，因为 info 等级vite:report 会输出文件列表等信息
+                optimizeDeps: {
+                    noDiscovery: true,
+                    include: [],
+                },
+                css: (0, css_1.createCss)(options, config),
+            };
+        },
+        configResolved(config) {
+            (0, configResolved_1.initLogger)(config);
+        },
+    };
+}
+exports.uniUVuePlugin = uniUVuePlugin;

node_modules/@dcloudio/vite-plugin-uni/dist/vue/index.d.ts

@@ -0,0 +1 @@
+export * from './options';

node_modules/@dcloudio/vite-plugin-uni/dist/vue/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+__exportStar(require("./options"), exports);

node_modules/@dcloudio/vite-plugin-uni/dist/vue/options.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin } from 'vite';
+import type { TemplateCompiler } from '@vue/compiler-sfc';
+import type { Options as VueOptions } from '@vitejs/plugin-vue';
+import { type UniVitePlugin } from '@dcloudio/uni-cli-shared';
+import type { ViteLegacyOptions, VitePluginUniResolvedOptions } from '..';
+/**
+ * 每次创建新的 plugin-vue 实例。因为该插件内部会 cache  descriptor，而相同的vue文件在编译到vue页面和nvue页面时，不能共享缓存（条件编译，css scoped等均不同）
+ * @returns
+ */
+export declare function createPluginVueInstance(options: VueOptions): Plugin<any>;
+export declare function initPluginVueOptions(options: VitePluginUniResolvedOptions, UniVitePlugins: UniVitePlugin[], uniPluginOptions: Required<Omit<Required<UniVitePlugin>['uni'], 'compiler'>> & {
+    compiler?: TemplateCompiler;
+}): VueOptions;
+export declare function initPluginVueJsxOptions(options: VitePluginUniResolvedOptions, { isCustomElement, }: Required<Required<UniVitePlugin>['uni']>['compilerOptions'], jsxOptions: Required<Required<UniVitePlugin>['uni']>['jsxOptions']): import("@vue/babel-plugin-jsx").VueJSXPluginOptions & {
+    babelPlugins?: any[] | undefined;
+};
+export declare function initPluginViteLegacyOptions(options: VitePluginUniResolvedOptions): ViteLegacyOptions;

node_modules/@dcloudio/vite-plugin-uni/dist/vue/options.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPluginViteLegacyOptions = exports.initPluginVueJsxOptions = exports.initPluginVueOptions = exports.createPluginVueInstance = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const utils_1 = require("../utils");
+const uni_cli_shared_2 = require("@dcloudio/uni-cli-shared");
+const pluginVuePath = require.resolve('@vitejs/plugin-vue');
+const normalizedPluginVuePath = (0, uni_cli_shared_1.normalizePath)(pluginVuePath);
+/**
+ * 每次创建新的 plugin-vue 实例。因为该插件内部会 cache  descriptor，而相同的vue文件在编译到vue页面和nvue页面时，不能共享缓存（条件编译，css scoped等均不同）
+ * @returns
+ */
+function createPluginVueInstance(options) {
+    delete require.cache[pluginVuePath];
+    delete require.cache[normalizedPluginVuePath];
+    const vuePlugin = require('@vitejs/plugin-vue');
+    const vuePluginInstance = vuePlugin(options);
+    if (process.env.NODE_ENV === 'development') {
+        // 删除 buildEnd 逻辑，因为里边清理了缓存，导致 watch 模式失效 https://github.com/vitejs/vite-plugin-vue/commit/96dbb220ff210d2f7391f43a807bcd8cfb0da776
+        delete vuePluginInstance.buildEnd;
+    }
+    return vuePluginInstance;
+}
+exports.createPluginVueInstance = createPluginVueInstance;
+function initPluginVueOptions(options, UniVitePlugins, uniPluginOptions) {
+    const vueOptions = options.vueOptions || (options.vueOptions = {});
+    // if (!hasOwn(vueOptions, 'reactivityTransform')) {
+    //   vueOptions.reactivityTransform = true
+    // }
+    if (!vueOptions.include) {
+        vueOptions.include = [];
+    }
+    if (!(0, shared_1.isArray)(vueOptions.include)) {
+        vueOptions.include = [vueOptions.include];
+    }
+    vueOptions.include.push(uni_cli_shared_1.EXTNAME_VUE_RE);
+    const styleOptions = vueOptions.style || (vueOptions.style = {});
+    if (!styleOptions.postcssPlugins) {
+        styleOptions.postcssPlugins = [];
+    }
+    // 解析 scoped 中 deep 等特殊语法
+    styleOptions.postcssPlugins.push((0, uni_cli_shared_1.uniPostcssScopedPlugin)());
+    const templateOptions = vueOptions.template || (vueOptions.template = {});
+    const compilerOptions = templateOptions.compilerOptions || (templateOptions.compilerOptions = {});
+    compilerOptions.isX = process.env.UNI_APP_X === 'true';
+    const { compiler, styleOptions: { postcssPlugins }, compilerOptions: { miniProgram, isNativeTag, isCustomElement, nodeTransforms, directiveTransforms, whitespace, }, } = uniPluginOptions;
+    if (postcssPlugins) {
+        styleOptions.postcssPlugins.push(...postcssPlugins);
+    }
+    if (compiler) {
+        templateOptions.compiler = compiler;
+    }
+    if (miniProgram) {
+        ;
+        compilerOptions.miniProgram = miniProgram;
+    }
+    if (isNativeTag) {
+        const userIsNativeTag = compilerOptions.isNativeTag;
+        compilerOptions.isNativeTag = (tag) => {
+            if (isNativeTag(tag)) {
+                return true;
+            }
+            if (userIsNativeTag && userIsNativeTag(tag)) {
+                return true;
+            }
+            return false;
+        };
+    }
+    if (whitespace) {
+        compilerOptions.whitespace = whitespace;
+    }
+    if (isCustomElement) {
+        const userIsCustomElement = compilerOptions.isCustomElement;
+        compilerOptions.isCustomElement = (tag) => {
+            if (isCustomElement(tag)) {
+                return true;
+            }
+            if (userIsCustomElement && userIsCustomElement(tag)) {
+                return true;
+            }
+            return false;
+        };
+    }
+    compilerOptions.directiveTransforms = {
+        ...compilerOptions.directiveTransforms,
+        ...directiveTransforms,
+    };
+    if (!compilerOptions.nodeTransforms) {
+        compilerOptions.nodeTransforms = [];
+    }
+    // 合并 transformAssetUrls
+    // 内置配置
+    const builtInTransformAssetUrls = (0, uni_cli_shared_1.createUniVueTransformAssetUrls)((0, uni_cli_shared_1.isExternalUrl)(options.base) ? options.base : '');
+    // 用户传递配置 eg: transformAssetUrls.tags = {'my-image': ['src']}
+    // docs: https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue
+    const userOptionsTransformAssetUrls = templateOptions.transformAssetUrls;
+    templateOptions.transformAssetUrls = builtInTransformAssetUrls;
+    if (typeof userOptionsTransformAssetUrls !== 'boolean' &&
+        !!userOptionsTransformAssetUrls?.tags &&
+        !Array.isArray(userOptionsTransformAssetUrls.tags)) {
+        templateOptions.transformAssetUrls = {
+            ...builtInTransformAssetUrls,
+            ...userOptionsTransformAssetUrls,
+            tags: {
+                ...builtInTransformAssetUrls.tags,
+                ...userOptionsTransformAssetUrls.tags,
+            },
+        };
+    }
+    if (options.platform !== 'h5' && options.platform !== 'web') {
+        compilerOptions.nodeTransforms.push(...(0, uni_cli_shared_1.getBaseNodeTransforms)(options.base));
+    }
+    if (nodeTransforms) {
+        compilerOptions.nodeTransforms.push(...nodeTransforms);
+    }
+    // const compatConfig = parseCompatConfigOnce(options.inputDir)
+    // compilerOptions.compatConfig = extend(
+    //   compilerOptions.compatConfig || {},
+    //   compatConfig
+    // )
+    // App,MP 平台不支持使用静态节点
+    compilerOptions.hoistStatic = false;
+    compilerOptions.root = process.env.UNI_INPUT_DIR;
+    const isX = process.env.UNI_APP_X === 'true';
+    // app-nvue | app-uvue 需要启用 customElement 机制来内联 styles
+    if (process.env.UNI_COMPILER === 'nvue' ||
+        (isX && options.platform === 'app')) {
+        vueOptions.customElement = true;
+        if (process.env.UNI_RENDERER_NATIVE !== 'appService' || isX) {
+            // nvue 需要使用自己的 compiler，来移除 scoped
+            vueOptions.compiler = (0, utils_1.createNVueCompiler)();
+        }
+    }
+    if (!vueOptions.script) {
+        vueOptions.script = {};
+    }
+    // TODO 目前暂不支持通过@/开头引入文件，因为需要tsconfig.json配置，建议使用相对路径
+    // https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/script/resolveType.ts#L911
+    require('@vue/compiler-sfc').registerTS(() => {
+        if (isX) {
+            return (0, uni_cli_shared_2.resolveUniTypeScript)();
+        }
+        return require('typescript');
+    });
+    if (!vueOptions.script.fs) {
+        function resolveFile(file) {
+            if (file.startsWith('@/')) {
+                file = file.replace('@/', (0, uni_cli_shared_1.normalizePath)(process.env.UNI_INPUT_DIR));
+            }
+            return file;
+        }
+        vueOptions.script.fs = {
+            fileExists(file) {
+                return fs_extra_1.default.existsSync(resolveFile(file));
+            },
+            readFile(file) {
+                // 需要走条件编译
+                return (0, uni_cli_shared_1.preJs)(fs_extra_1.default.readFileSync(resolveFile(file), 'utf-8'));
+            },
+            realpath(file) {
+                return resolveFile(file);
+            },
+        };
+    }
+    if (isX) {
+        if (!vueOptions.script) {
+            vueOptions.script = {
+                babelParserPlugins: [],
+            };
+        }
+        if (!vueOptions.script.babelParserPlugins) {
+            vueOptions.script.babelParserPlugins = [];
+        }
+        if (!vueOptions.script.babelParserPlugins.includes('typescript')) {
+            vueOptions.script.babelParserPlugins.push('typescript');
+        }
+        // decorators or decorators-legacy
+        if (!vueOptions.script.babelParserPlugins.includes('decorators')) {
+            vueOptions.script.babelParserPlugins.push('decorators');
+        }
+    }
+    return vueOptions;
+}
+exports.initPluginVueOptions = initPluginVueOptions;
+function initPluginVueJsxOptions(options, { isCustomElement, }, jsxOptions) {
+    const vueJsxOptions = (0, shared_1.isPlainObject)(options.vueJsxOptions)
+        ? options.vueJsxOptions
+        : (options.vueJsxOptions = {});
+    if (!(0, shared_1.hasOwn)(vueJsxOptions, 'optimize')) {
+        vueJsxOptions.optimize = true;
+    }
+    vueJsxOptions.isCustomElement = isCustomElement;
+    if (!vueJsxOptions.babelPlugins) {
+        vueJsxOptions.babelPlugins = [];
+    }
+    if ((0, shared_1.isArray)(jsxOptions.babelPlugins)) {
+        vueJsxOptions.babelPlugins.push(...jsxOptions.babelPlugins);
+    }
+    return vueJsxOptions;
+}
+exports.initPluginVueJsxOptions = initPluginVueJsxOptions;
+function initPluginViteLegacyOptions(options) {
+    const viteLegacyOptions = options.viteLegacyOptions || (options.viteLegacyOptions = {});
+    return viteLegacyOptions;
+}
+exports.initPluginViteLegacyOptions = initPluginViteLegacyOptions;