@pubinfo-pr/vite 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PUBINFO 腾龙框架
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index-kUIn8Mdx.d.ts

@@ -0,0 +1,100 @@
+import { UserConfig, UserConfigFnObject } from "rolldown-vite";
+import * as vite_plugin_vue_devtools0 from "vite-plugin-vue-devtools";
+import { VitePluginVueDevToolsOptions } from "vite-plugin-vue-devtools";
+import * as _pubinfo_unplugin_openapi0 from "@pubinfo/unplugin-openapi";
+import { Options } from "@pubinfo/unplugin-openapi";
+export * from "rolldown-vite";
+export * from "vite-plugin-fake-server/client";
+
+//#region src/plugins/built-in/inject-auto.d.ts
+interface InjectAutoOptions {
+  id: string;
+}
+/**
+ * 自动注入代码
+ */
+//#endregion
+//#region src/plugins/built-in/lib-resolver.d.ts
+type GlobInput = string;
+interface ModuleEntries {
+  /**
+   * 图标文件
+   * @default "src/assets/icons/**\/*"
+   */
+  icons?: GlobInput;
+  /**
+   * 布局文件
+   * @default "src/layouts/**\/*"
+   */
+  layouts?: GlobInput;
+  /**
+   * 页面文件
+   * @default "src/pages/**\/*"
+   */
+  pages?: GlobInput;
+}
+interface ResolverPluginOptions {
+  /** 入口配置 */
+  entries: ModuleEntries;
+}
+//#endregion
+//#region src/interface.d.ts
+interface CommitlintOptions {
+  /**
+   * Enable or disable commitlint for application repositories. Defaults to enabled.
+   */
+  enabled?: boolean;
+  /**
+   * Convenience flag mirroring `enabled: false`.
+   */
+  disable?: boolean;
+}
+interface PubinfoConfig {
+  /** `vite` */
+  vite?: UserConfig | UserConfigFnObject;
+  /** `@pubinfo/unplugin-openapi` */
+  openapi?: Options;
+  /** `resolver` */
+  resolver?: ResolverPluginOptions;
+  /** devtools */
+  devtools?: Omit<VitePluginVueDevToolsOptions, 'enabled'> & {
+    enabled?: boolean;
+  };
+  /** `commitlint` */
+  commitlint?: boolean | CommitlintOptions;
+}
+interface ModuleConfig extends PubinfoConfig {
+  /**
+   * `moduleId`
+   */
+  moduleId: InjectAutoOptions['id'];
+}
+//#endregion
+//#region src/config/index.d.ts
+/**
+ * 构建应用配置
+ */
+declare function definePubinfoConfig(config: PubinfoConfig): {
+  vite: UserConfigFnObject;
+  openapi?: _pubinfo_unplugin_openapi0.Options;
+  resolver?: ResolverPluginOptions;
+  devtools?: Omit<vite_plugin_vue_devtools0.VitePluginVueDevToolsOptions, "enabled"> & {
+    enabled?: boolean;
+  };
+  commitlint?: boolean | CommitlintOptions;
+};
+/**
+ * 构建模块配置
+ */
+declare function defineModuleConfig(config: ModuleConfig): {
+  vite: UserConfigFnObject;
+  moduleId: InjectAutoOptions["id"];
+  openapi?: _pubinfo_unplugin_openapi0.Options;
+  resolver?: ResolverPluginOptions;
+  devtools?: Omit<vite_plugin_vue_devtools0.VitePluginVueDevToolsOptions, "enabled"> & {
+    enabled?: boolean;
+  };
+  commitlint?: boolean | CommitlintOptions;
+};
+//#endregion
+export { CommitlintOptions, ModuleConfig, PubinfoConfig, ResolverPluginOptions, defineModuleConfig, definePubinfoConfig };

package/dist/index.js

@@ -0,0 +1,747 @@
+import { createRequire } from "node:module";
+import { defineConfig, loadEnv, mergeConfig, normalizePath } from "rolldown-vite";
+import process, { cwd } from "node:process";
+import { logger } from "@pubinfo-pr/shared";
+import chalk from "chalk";
+import path, { dirname, join, posix, relative, resolve } from "node:path";
+import vue from "@vitejs/plugin-vue";
+import vueJsx from "@vitejs/plugin-vue-jsx";
+import fs from "fs-extra";
+import boxen from "boxen";
+import MagicString from "magic-string";
+import fg from "fast-glob";
+import { merge } from "lodash-es";
+import picomatch from "picomatch";
+import "micromatch";
+import { execSync } from "node:child_process";
+import dayjs from "dayjs";
+import { readPackageJSON } from "pkg-types";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { Buffer } from "node:buffer";
+import fse from "fs-extra/esm";
+import JSZip from "jszip";
+import autoImport from "unplugin-auto-import/vite";
+import IconsResolver from "unplugin-icons/resolver";
+import { AntDesignVueResolver } from "unplugin-vue-components/resolvers";
+import components from "unplugin-vue-components/vite";
+import compression from "vite-plugin-compression";
+import { pubinfoDevtools } from "@pubinfo-pr/devtools";
+import dts from "vite-plugin-dts";
+import Icons from "unplugin-icons/vite";
+import { libInjectCss } from "vite-plugin-lib-inject-css";
+import VueDevTools from "vite-plugin-vue-devtools";
+import vueLegacy from "@vitejs/plugin-legacy";
+import { vitePluginFakeServer } from "vite-plugin-fake-server";
+import OpenAPI from "@pubinfo/unplugin-openapi/vite";
+import Unocss from "unocss/vite";
+
+export * from "rolldown-vite"
+
+export * from "vite-plugin-fake-server/client"
+
+//#region src/helper/alias.ts
+function alias(root) {
+	const resolvePath = (name) => join(root, name);
+	const resolveDeps = (name, path$1) => join(createRequire(import.meta.url).resolve(name), path$1);
+	return {
+		"@": resolvePath("src"),
+		"#": resolvePath("types"),
+		"vue": resolveDeps("vue", "../"),
+		"vue-router": resolveDeps("vue-router", "../"),
+		"pinia": resolveDeps("pinia", "../"),
+		"unocss": resolveDeps("unocss", "../")
+	};
+}
+
+//#endregion
+//#region src/helper/index.ts
+function getServerProxy(env, isProxy) {
+	if (!isProxy) return {};
+	const targetPrefix = "VITE_APP_API_";
+	const proxyKey = Object.keys(env).filter((key) => key.startsWith(targetPrefix));
+	const serverProxy = {};
+	for (const envKey of proxyKey) {
+		const url = env[envKey];
+		const { pathname } = new URL(url);
+		const pk = `${pathname}/proxy`;
+		if (pk in serverProxy) logger.warn(`The env key ${chalk.bold.yellowBright(envKey)} ➜ ${chalk.bold.green(url)} already exists`);
+		else serverProxy[pk] = {
+			target: url,
+			changeOrigin: true,
+			rewrite: (path$1) => path$1.replace(pk, ""),
+			secure: false
+		};
+	}
+	return serverProxy;
+}
+
+//#endregion
+//#region src/plugins/built-in/clean-build.ts
+function createCleanBuild() {
+	let config;
+	return {
+		name: "vite-plugin-clean-build",
+		apply: "build",
+		enforce: "post",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		buildStart() {
+			const outDir = config.build.outDir;
+			const root = config.root;
+			const outputPath = path.resolve(root, outDir);
+			if (fs.existsSync(outputPath)) try {
+				fs.rmSync(outputPath, {
+					recursive: true,
+					force: true
+				});
+			} catch (error) {
+				logger.error(`[vite-plugin-clean-build] Failed to clean build directory: ${error}`);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/built-in/info.ts
+var Ctx$1 = class {
+	options;
+	setOptions(options) {
+		this.options = options;
+	}
+	async createInfo() {
+		console.log(boxen(`\
+欢迎使用${chalk.bold.greenBright(" 产数研发底座系统 ")}\n
+${chalk.green("使用文档地址")} ${chalk.green("➜")} https://134.108.39.195:9090/docs`, {
+			padding: 1,
+			margin: 1,
+			align: "center",
+			borderColor: "yellowBright",
+			borderStyle: "round"
+		}));
+	}
+};
+const ctx$1 = new Ctx$1();
+function createAppInfo() {
+	return {
+		name: "createAppInfo",
+		apply: "serve",
+		enforce: "pre",
+		configResolved(configuration) {
+			const root = configuration.root;
+			ctx$1.setOptions({ root });
+		},
+		async buildStart() {
+			ctx$1.createInfo();
+		},
+		configureServer(server) {
+			const _printUrls = server.printUrls;
+			server.printUrls = () => {
+				console.log(`  ${chalk.green("➜")}  ${chalk.bold.bgBlueBright(` PUBINFO `)}${chalk.bold.bgYellowBright(` 前端基础框架 `)}`);
+				_printUrls();
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/built-in/inject-auto.ts
+/**
+* 自动注入代码
+*/
+function createInjectAuto(options) {
+	const { id } = options;
+	let entryFiles = [];
+	return {
+		name: "vite-plugin-inject-auto",
+		enforce: "pre",
+		configResolved(config) {
+			const lib = config.build?.lib;
+			if (!lib || !lib.entry) return;
+			const toAbs = (p) => resolve(config.root, p);
+			if (typeof lib.entry === "string") entryFiles = [toAbs(lib.entry)];
+			else if (Array.isArray(lib.entry)) entryFiles = lib.entry.map(toAbs);
+			else if (typeof lib.entry === "object") entryFiles = Object.values(lib.entry).map(toAbs);
+		},
+		transform(code, _id) {
+			if (entryFiles.includes(_id)) {
+				const s = new MagicString(code);
+				const injectCode = `
+          import { defineRouteModule, defineIconModule } from 'pubinfo-pr';
+          import modules from 'virtual:pubinfo-resolver';
+
+          defineRouteModule('${id}', modules.pages);
+          defineIconModule('${id}', modules.icons);
+
+        `;
+				s.prepend(injectCode);
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: true })
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/built-in/lib-resolver.ts
+function getPatternBase(pattern) {
+	const parts = pattern.split("/");
+	const baseParts = [];
+	for (const part of parts) {
+		if (part.includes("*")) break;
+		baseParts.push(part);
+	}
+	return baseParts.join("/");
+}
+function normalizePath$1(path$1) {
+	return posix.normalize(path$1.replace(/\\/g, "/"));
+}
+function libResolverPlugin(options) {
+	const virtualModuleId = "virtual:pubinfo-resolver";
+	const resolvedId = `\0${virtualModuleId}`;
+	let serverRoot = "";
+	function sendUpdate(server, action, file) {
+		const payload = {
+			action,
+			file,
+			timestamp: Date.now()
+		};
+		server.ws.send({
+			type: "custom",
+			event: "pubinfo-resolver:update",
+			data: payload
+		});
+	}
+	function isMatchingFile(file) {
+		const normalizedFile = normalizePath$1(file);
+		const isVueOrTsFile = /\.(vue|tsx?|jsx?)$/.test(normalizedFile);
+		const relativePath = serverRoot ? normalizePath$1(relative(serverRoot, normalizedFile)) : normalizedFile;
+		return Object.values(options.entries).some((pattern, index) => {
+			return picomatch(pattern)(relativePath);
+		}) && isVueOrTsFile;
+	}
+	return {
+		name: "vite-plugin-lib-resolver",
+		enforce: "pre",
+		buildStart() {},
+		configureServer(server) {
+			serverRoot = server.config.root;
+			const encodedPath = "/@id/__x00__virtual:pubinfo-resolver";
+			server.middlewares.use((req, _res, next) => {
+				if (req.url && req.url.startsWith(encodedPath)) {
+					const mod = server.moduleGraph.getModuleById(resolvedId);
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}
+				next();
+			});
+			server.watcher.on("add", (file) => {
+				if (isMatchingFile(file)) sendUpdate(server, "add", file);
+			});
+			server.watcher.on("unlink", (file) => {
+				if (isMatchingFile(file)) sendUpdate(server, "unlink", file);
+			});
+			const patterns = Object.values(options.entries);
+			const bases = patterns.map((pattern) => {
+				const base = getPatternBase(pattern);
+				return resolve(server.config.root, base);
+			});
+			server.watcher.add([...patterns.map((p) => resolve(server.config.root, p)), ...bases]);
+		},
+		async resolveId(id) {
+			return id === virtualModuleId ? resolvedId : null;
+		},
+		async load(id) {
+			if (id !== resolvedId) return null;
+			return `export default {\n  ${(await Promise.all(Object.entries(options.entries).map(async ([key, pattern]) => {
+				try {
+					const files = await fg(pattern, { absolute: true });
+					if (files.length === 0) return {
+						key,
+						content: `"${key}": {}`,
+						files: []
+					};
+					const base = getPatternBase(pattern);
+					return {
+						key,
+						content: `"${key}": {\n${files.map((file) => {
+							const absPath = normalizePath$1(file);
+							const relToBase = normalizePath$1(relative(resolve(base), file));
+							return `"${posix.join(base, relToBase)}": () => import("${absPath}")`;
+						}).join(",\n")}\n  }`,
+						files
+					};
+				} catch (error) {
+					console.error(`[lib-resolver] Error processing pattern "${pattern}":`, error);
+					return {
+						key,
+						content: `"${key}": {}`,
+						files: []
+					};
+				}
+			}))).map((result) => result.content).join(",\n  ")}\n}`;
+		}
+	};
+}
+function createLibResolver(options) {
+	return libResolverPlugin(merge({ entries: {
+		icons: "src/assets/icons/**/*",
+		layouts: "src/layouts/*.vue",
+		pages: "src/views/**/*.vue"
+	} }, options));
+}
+
+//#endregion
+//#region src/plugins/built-in/system-info.ts
+function hasGitRepository() {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasGitCommit() {
+	try {
+		execSync("git rev-parse --verify HEAD", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getGitInfo() {
+	if (!hasGitRepository() || !hasGitCommit()) return {
+		commit: "",
+		commitShort: "",
+		branch: ""
+	};
+	try {
+		const commit = execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+		const commitShort = execSync("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+		let branch = process.env.GITHUB_REF_NAME || process.env.CI_COMMIT_REF_NAME || process.env.GIT_BRANCH || process.env.BRANCH_NAME;
+		if (!branch) {
+			branch = execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8" }).trim();
+			if (branch === "HEAD") try {
+				const branches = execSync(`git show-ref --heads | grep ${commit}`, { encoding: "utf-8" }).trim();
+				if (branches) {
+					const match = branches.split("\n")[0].match(/refs\/heads\/(.+)$/);
+					if (match) branch = match[1];
+				}
+			} catch {}
+		}
+		return {
+			commit,
+			commitShort,
+			branch
+		};
+	} catch {
+		return {
+			commit: "",
+			commitShort: "",
+			branch: ""
+		};
+	}
+}
+function createSystemInfo(options = {}) {
+	const defineKey = options.defineKey || "__SYSTEM_INFO__";
+	return {
+		name: "vite-plugin-system-info",
+		async config() {
+			const pkg = await readPackageJSON();
+			const systemInfo = {
+				buildTime: dayjs().format("YYYY-MM-DD HH:mm:ss"),
+				pkg,
+				git: getGitInfo()
+			};
+			return { define: { [defineKey]: JSON.stringify(systemInfo) } };
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/built-in/virtual-inspector.ts
+function getInspectorPath() {
+	return normalizePath(dirname(fileURLToPath(import.meta.url)));
+}
+function createVirtualInspectorPlugin(options = {}) {
+	const { enabled = true } = options;
+	const inspectorPath = getInspectorPath();
+	const virtualModuleId = "virtual:vite-pubinfo-inspector:load.js";
+	let config;
+	return {
+		name: "vite-plugin-virtual-inspector",
+		enforce: "pre",
+		configureServer(server) {
+			if (!enabled) return;
+			server.middlewares.use("/__pubinfo_inspector__", (req, res, next) => {
+				if (req.url === "/info") {
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify({
+						virtualModule: virtualModuleId,
+						enabled: true,
+						timestamp: (/* @__PURE__ */ new Date()).toISOString()
+					}));
+				} else next();
+			});
+		},
+		async resolveId(importee) {
+			if (config?.command !== "serve") return null;
+			if (importee === virtualModuleId) return resolve(inspectorPath, "load.js");
+			return null;
+		},
+		async load(id) {
+			if (config?.command !== "serve") return null;
+			if (id.includes("load.js") && id.includes(inspectorPath)) {
+				if (!enabled) return "export default {};";
+				const filePath = resolve(inspectorPath, "load.js");
+				if (existsSync(filePath)) return await readFile(filePath, "utf-8");
+				else {
+					console.error(`Failed to find file for pubinfo-inspector: ${filePath}`);
+					return "export default { error: \"Failed to load inspector content\" };";
+				}
+			}
+			return null;
+		},
+		transformIndexHtml(html) {
+			if (!enabled || config?.command !== "serve") return;
+			return {
+				html,
+				tags: [{
+					tag: "script",
+					injectTo: "head",
+					attrs: {
+						type: "module",
+						src: `${config?.base || "/"}@id/${virtualModuleId}`
+					}
+				}]
+			};
+		},
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		}
+	};
+}
+function createVirtualInspector(options) {
+	return createVirtualInspectorPlugin(options);
+}
+
+//#endregion
+//#region src/plugins/built-in/zip.ts
+var Ctx = class {
+	root;
+	outDirName;
+	dir;
+	outDir;
+	setOptions(options) {
+		this.root = options.root;
+		this.outDirName = options.outDirName;
+		this.getDirPath();
+	}
+	getDirPath() {
+		const dir = resolve(this.root, this.outDirName);
+		const outDir = `${dir}.zip`;
+		this.dir = dir;
+		this.outDir = outDir;
+	}
+	async clean() {
+		if (await fse.pathExists(this.outDir)) fse.remove(this.outDir);
+	}
+	async compress() {
+		const zip = new JSZip();
+		const files = this.getAllFiles(this.dir);
+		if (files && Array.isArray(files) && files.length) files.forEach((file) => {
+			const fileData = readFileSync(file, { encoding: "binary" });
+			zip.file(relative(this.dir, file), fileData, { binary: true });
+		});
+		const content = await zip.generateAsync({ type: "arraybuffer" });
+		writeFileSync(this.outDir, Buffer.from(content));
+	}
+	getAllFiles(dirPath) {
+		const files = readdirSync(dirPath);
+		const result = [];
+		for (const file of files) {
+			const filePath = join(dirPath, file);
+			if (statSync(filePath).isDirectory()) result.push(...this.getAllFiles(filePath));
+			else result.push(filePath);
+		}
+		return result;
+	}
+};
+const ctx = new Ctx();
+
+//#endregion
+//#region src/plugins/intergrations/auto-import.ts
+function createAutoImport() {
+	return autoImport({
+		imports: [
+			"vue",
+			"vue-router",
+			"pinia",
+			{ pubinfo: ["useAuth"] }
+		],
+		ignore: ["h"],
+		dts: "./.pubinfo/auto-imports.d.ts",
+		resolvers: [AntDesignVueResolver(), IconsResolver({ prefix: "i" })]
+	});
+}
+
+//#endregion
+//#region src/plugins/intergrations/components.ts
+function createComponents() {
+	return components({
+		dirs: ["src/components"],
+		directives: true,
+		include: [
+			/\.vue$/,
+			/\.vue\?vue/,
+			/\.tsx$/
+		],
+		resolvers: [
+			IconsResolver(),
+			AntDesignVueResolver({
+				resolveIcons: true,
+				importStyle: false
+			}),
+			{
+				type: "component",
+				resolve(name) {
+					if ([
+						"PubinfoApp",
+						"PubinfoProvider",
+						"PubinfoIcon"
+					].includes(name)) return {
+						name,
+						from: "pubinfo-pr"
+					};
+				}
+			}
+		],
+		dts: "./.pubinfo/components.d.ts"
+	});
+}
+
+//#endregion
+//#region src/plugins/intergrations/compression.ts
+function createCompression(env) {
+	const { VITE_BUILD_COMPRESS } = env;
+	const compressList = VITE_BUILD_COMPRESS?.split(",") ?? [];
+	const plugin = [];
+	if (compressList.includes("gzip")) plugin.push(compression({
+		ext: ".gz",
+		deleteOriginFile: false
+	}));
+	if (compressList.includes("brotli")) plugin.push(compression({
+		ext: ".br",
+		algorithm: "brotliCompress",
+		deleteOriginFile: false
+	}));
+	return plugin;
+}
+
+//#endregion
+//#region src/plugins/intergrations/devtools.ts
+function createPubinfoDevtoolsPlugin() {
+	return pubinfoDevtools();
+}
+
+//#endregion
+//#region src/plugins/intergrations/dts.ts
+function createDTS() {
+	return dts({
+		clearPureImport: false,
+		exclude: ["tests/**/*", ".pubinfo/**/*"]
+	});
+}
+
+//#endregion
+//#region src/plugins/intergrations/icon.ts
+function createIcons() {
+	return Icons({ autoInstall: false });
+}
+
+//#endregion
+//#region src/plugins/intergrations/inject-css.ts
+function createInjectCSS() {
+	return libInjectCss();
+}
+
+//#endregion
+//#region src/plugins/intergrations/inspector.ts
+function createInspector(devtoolsConfig) {
+	if (devtoolsConfig?.enabled) return VueDevTools({ ...devtoolsConfig });
+	else return null;
+}
+
+//#endregion
+//#region src/plugins/intergrations/legacy.ts
+function createLegacy(env) {
+	if (env.VITE_BUILD_LEGACY !== "true") return false;
+	return vueLegacy({
+		modernPolyfills: ["es.array.at", "es.array.find-last"],
+		additionalLegacyPolyfills: ["abort-controller/polyfill"]
+	});
+}
+
+//#endregion
+//#region src/plugins/intergrations/mock.ts
+function createMock(env, isBuild) {
+	const { VITE_BUILD_MOCK } = env;
+	if (!existsSync(resolve(cwd(), "src/mock"))) return;
+	return vitePluginFakeServer({
+		logger: !isBuild,
+		include: "src/mock",
+		infixName: false,
+		enableProd: isBuild && VITE_BUILD_MOCK === "true"
+	});
+}
+
+//#endregion
+//#region src/plugins/intergrations/openapi.ts
+function createOpenAPI(options) {
+	return OpenAPI(options || { enabled: false });
+}
+
+//#endregion
+//#region src/plugins/intergrations/unocss.ts
+function createUnocss() {
+	return Unocss();
+}
+
+//#endregion
+//#region src/plugins/index.ts
+function createVitePlugins(viteEnv, isBuild = false, config, type) {
+	return [
+		vue(),
+		vueJsx(),
+		createLegacy(viteEnv),
+		createAutoImport(),
+		createComponents(),
+		createUnocss(),
+		createIcons(),
+		createMock(viteEnv, isBuild),
+		createInspector(config.devtools),
+		createPubinfoDevtoolsPlugin(),
+		createOpenAPI(config.openapi),
+		createLibResolver(config.resolver),
+		createAppInfo(),
+		createVirtualInspector({ enabled: true }),
+		createSystemInfo(),
+		type === "module" ? [
+			createDTS(),
+			createInjectCSS(),
+			createInjectAuto({ id: config.moduleId })
+		] : [createCleanBuild()],
+		isBuild ? createCompression(viteEnv) : null
+	].filter(Boolean);
+}
+
+//#endregion
+//#region src/config/application.ts
+function createDefaultAppConfig(config) {
+	return ({ mode, command }) => {
+		const root = cwd();
+		const isBuild = command === "build";
+		const timestamp = (/* @__PURE__ */ new Date()).getTime();
+		const env = loadEnv(mode, root);
+		const { VITE_OPEN_PROXY, VITE_BUILD_SOURCEMAP } = env;
+		return {
+			base: "./",
+			server: {
+				open: true,
+				host: true,
+				proxy: getServerProxy(env, !isBuild && VITE_OPEN_PROXY === "true"),
+				warmup: { clientFiles: ["./index.html"] }
+			},
+			optimizeDeps: { exclude: [
+				"pubinfo-pr",
+				"@pubinfo-pr/core",
+				"alova"
+			] },
+			resolve: { alias: alias(root) },
+			build: {
+				outDir: mode === "production" ? "dist" : `dist-${mode}`,
+				sourcemap: VITE_BUILD_SOURCEMAP === "true",
+				reportCompressedSize: false,
+				chunkSizeWarningLimit: 2e3,
+				rolldownOptions: { output: {
+					entryFileNames: `assets/entry/[name]-[hash]-${timestamp}.js`,
+					advancedChunks: { groups: [{
+						name: "pubinfo-pr",
+						test: "pubinfo-pr"
+					}] }
+				} }
+			},
+			plugins: createVitePlugins(env, isBuild, config, "app")
+		};
+	};
+}
+
+//#endregion
+//#region src/config/module.ts
+function createDefaultModuleConfig(config) {
+	return ({ mode, command }) => {
+		const root = cwd();
+		const isBuild = command === "build";
+		const env = loadEnv(mode, root);
+		return {
+			optimizeDeps: { exclude: [
+				"pubinfo-pr",
+				"@pubinfo-pr/core",
+				"alova"
+			] },
+			resolve: { alias: alias(root) },
+			build: { rolldownOptions: {
+				preserveEntrySignatures: "allow-extension",
+				external: [
+					"vue",
+					"vue-router",
+					"pinia",
+					"unocss"
+				]
+			} },
+			plugins: createVitePlugins(env, isBuild, config, "module")
+		};
+	};
+}
+
+//#endregion
+//#region src/config/index.ts
+/**
+* 构建应用配置
+*/
+function definePubinfoConfig(config) {
+	return {
+		...config,
+		vite: mergeViteConfig(createDefaultAppConfig(config), config)
+	};
+}
+/**
+* 构建模块配置
+*/
+function defineModuleConfig(config) {
+	return {
+		...config,
+		vite: mergeViteConfig(createDefaultModuleConfig(config), config)
+	};
+}
+/**
+* 合并默认Vite配置
+*/
+function mergeViteConfig(defaultOptions, config = {}) {
+	const { vite: viteOptions = {} } = config;
+	return defineConfig(({ mode, command }) => {
+		return mergeConfig(defaultOptions({
+			mode,
+			command
+		}), typeof viteOptions === "function" ? viteOptions({
+			mode,
+			command
+		}) : viteOptions);
+	});
+}
+
+//#endregion
+export { defineModuleConfig, definePubinfoConfig };

package/dist/load.js

@@ -0,0 +1,267 @@
+// Vite Pubinfo Inspector Virtual Module
+
+// 检查器工具函数
+export const inspectorUtils = {
+  // 获取当前环境信息
+  getEnvInfo() {
+    return {
+      nodeEnv: 'development', // 简化处理，直接设置为开发模式
+      mode: import.meta.env.MODE,
+      dev: import.meta.env.DEV,
+      prod: import.meta.env.PROD,
+      ssr: import.meta.env.SSR,
+    };
+  },
+
+  // 获取Vite信息
+  getViteInfo() {
+    return {
+      hmr: import.meta.hot ? 'enabled' : 'disabled',
+      base: import.meta.env.BASE_URL,
+      url: import.meta.url,
+    };
+  },
+
+  // WebSocket 连接工具
+  websocket: {
+    // 获取 HMR WebSocket 连接信息
+    getHMRConnection() {
+      if (!import.meta.hot) {
+        return null;
+      }
+
+      // 通过 import.meta.hot 获取内部的 transport 和连接信息
+      // 注意：这些是内部 API，可能会在 Vite 版本更新时发生变化
+      const hotContext = import.meta.hot;
+
+      // 尝试访问内部的 HMR 客户端
+      const hmrClient = hotContext?.__viteHmrClient || hotContext?._hmrClient;
+
+      return {
+        isAvailable: !!hotContext,
+        client: hmrClient,
+        // 提供一些基本的连接信息
+        connectionState: hmrClient?.transport ? 'connected' : 'disconnected',
+      };
+    },
+
+    // 发送自定义 WebSocket 消息
+    send(event, data) {
+      if (!import.meta.hot) {
+        console.warn('[Pubinfo Inspector] HMR not available');
+        return false;
+      }
+
+      try {
+        import.meta.hot.send(event, data);
+        return true;
+      }
+      catch (error) {
+        console.error('[Pubinfo Inspector] Failed to send WebSocket message:', error);
+        return false;
+      }
+    },
+
+    // 监听自定义 WebSocket 事件
+    on(event, callback) {
+      if (!import.meta.hot) {
+        console.warn('[Pubinfo Inspector] HMR not available');
+        return () => {};
+      }
+
+      try {
+        import.meta.hot.on(event, callback);
+
+        // 返回取消监听的函数
+        return () => {
+          try {
+            import.meta.hot.off(event, callback);
+          }
+          catch (error) {
+            console.error('[Pubinfo Inspector] Failed to remove WebSocket listener:', error);
+          }
+        };
+      }
+      catch (error) {
+        console.error('[Pubinfo Inspector] Failed to add WebSocket listener:', error);
+        return () => {};
+      }
+    },
+
+    // 监听 WebSocket 连接状态变化
+    onConnectionChange(callback) {
+      if (!import.meta.hot) {
+        console.warn('[Pubinfo Inspector] HMR not available');
+        return () => {};
+      }
+
+      const listeners = [];
+
+      // 监听连接建立
+      const offConnect = this.on('vite:ws:connect', () => {
+        callback('connected');
+      });
+      listeners.push(offConnect);
+
+      // 监听连接断开
+      const offDisconnect = this.on('vite:ws:disconnect', () => {
+        callback('disconnected');
+      });
+      listeners.push(offDisconnect);
+
+      // 返回取消所有监听的函数
+      return () => {
+        listeners.forEach(off => off());
+      };
+    },
+
+    // 获取 WebSocket 连接的详细信息
+    getConnectionDetails() {
+      const connection = this.getHMRConnection();
+
+      if (!connection || !connection.isAvailable) {
+        return null;
+      }
+
+      // 尝试获取更多连接详细信息
+      const details = {
+        state: connection.connectionState,
+        url: null,
+        protocol: null,
+        readyState: null,
+      };
+
+      try {
+        // 尝试从内部访问 WebSocket 实例
+        const transport = connection.client?.transport;
+        if (transport?.socket) {
+          details.url = transport.socket.url;
+          details.protocol = transport.socket.protocol;
+          details.readyState = transport.socket.readyState;
+        }
+      }
+      catch (error) {
+        // 静默处理错误，因为这些是内部 API
+      }
+
+      return details;
+    },
+
+    // 测试 WebSocket 连接
+    async testConnection() {
+      if (!import.meta.hot) {
+        return { success: false, error: 'HMR not available' };
+      }
+
+      try {
+        // 发送一个测试事件
+        const testEventName = `pubinfo:test:${Date.now()}`;
+        let received = false;
+
+        // 监听响应
+        const off = this.on(`${testEventName}:response`, () => {
+          received = true;
+        });
+
+        // 发送测试消息
+        this.send(testEventName, { timestamp: Date.now() });
+
+        // 等待响应（超时 5 秒）
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        off();
+
+        return {
+          success: true,
+          connectionWorking: received,
+          details: this.getConnectionDetails(),
+        };
+      }
+      catch (error) {
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+  },
+
+  // 性能监控
+  performance: {
+    mark: (name) => {
+      if (typeof performance !== 'undefined' && performance.mark) {
+        performance.mark(name);
+      }
+    },
+    measure: (name, startMark, endMark) => {
+      if (typeof performance !== 'undefined' && performance.measure) {
+        try {
+          performance.measure(name, startMark, endMark);
+          const entries = performance.getEntriesByName(name);
+          return entries[entries.length - 1];
+        }
+        catch (e) {
+          console.warn('Performance measurement failed:', e);
+          return null;
+        }
+      }
+      return null;
+    },
+  },
+};
+
+// 导出默认对象
+export default inspectorUtils;
+
+// 全局访问接口 - 让其他模块可以访问 WebSocket 功能
+if (typeof globalThis !== 'undefined') {
+  // 在全局对象上暴露 WebSocket 工具
+  globalThis.__PUBINFO_WEBSOCKET__ = {
+    // 发送消息
+    send: (event, data) => inspectorUtils.websocket.send(event, data),
+
+    // 监听事件
+    on: (event, callback) => inspectorUtils.websocket.on(event, callback),
+
+    // 获取连接信息
+    getConnection: () => inspectorUtils.websocket.getHMRConnection(),
+
+    // 获取连接详情
+    getDetails: () => inspectorUtils.websocket.getConnectionDetails(),
+
+    // 测试连接
+    test: () => inspectorUtils.websocket.testConnection(),
+
+    // 监听连接状态
+    onStateChange: callback => inspectorUtils.websocket.onConnectionChange(callback),
+  };
+}
+
+// HMR 支持 - 静默接受热更新，避免页面重新加载
+if (import.meta.hot) {
+  // 静默接受热更新，不输出日志，避免噪音
+  import.meta.hot.accept(() => {
+    // 静默重新初始化全局接口，不输出任何日志
+    if (typeof globalThis !== 'undefined') {
+      globalThis.__PUBINFO_WEBSOCKET__ = {
+        send: (event, data) => inspectorUtils.websocket.send(event, data),
+        on: (event, callback) => inspectorUtils.websocket.on(event, callback),
+        getConnection: () => inspectorUtils.websocket.getHMRConnection(),
+        getDetails: () => inspectorUtils.websocket.getConnectionDetails(),
+        test: () => inspectorUtils.websocket.testConnection(),
+        onStateChange: callback => inspectorUtils.websocket.onConnectionChange(callback),
+      };
+    }
+  });
+
+  // HMR 数据持久化
+  import.meta.hot.dispose((data) => {
+    // 静默保存当前状态
+    data.connectionInfo = inspectorUtils.websocket.getConnectionDetails();
+  });
+
+  // 静默从之前的状态恢复
+  if (import.meta.hot.data?.connectionInfo) {
+    // 静默恢复，不输出日志
+  }
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@pubinfo-pr/vite",
+  "type": "module",
+  "version": "0.1.1",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.17"
+  },
+  "dependencies": {
+    "@pubinfo-pr/devtools": "0.1.1",
+    "@pubinfo-pr/shared": "0.1.1",
+    "@pubinfo/unplugin-openapi": "^0.9.1",
+    "@vitejs/plugin-legacy": "^7.2.1",
+    "@vitejs/plugin-vue": "^6.0.0",
+    "@vitejs/plugin-vue-jsx": "^5.0.1",
+    "abort-controller": "^3.0.0",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "dayjs": "^1.11.13",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.0",
+    "jszip": "^3.10.1",
+    "lodash-es": "^4.17.21",
+    "magic-string": "^0.30.19",
+    "micromatch": "^4.0.8",
+    "picomatch": "^4.0.3",
+    "pkg-types": "^2.3.0",
+    "rolldown-vite": "^7.1.2",
+    "terser": "^5.43.1",
+    "unocss": "^66.4.2",
+    "unplugin-auto-import": "^20.0.0",
+    "unplugin-icons": "^22.2.0",
+    "unplugin-vue-components": "^29.0.0",
+    "vite-plugin-compression": "^0.5.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-env-runtime": "^0.3.6",
+    "vite-plugin-fake-server": "^2.2.0",
+    "vite-plugin-lib-inject-css": "^2.2.2",
+    "vite-plugin-vue-devtools": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/lodash-es": "^4.17.12",
+    "@types/micromatch": "^4.0.9",
+    "@types/node": "^24.0.10",
+    "@types/picomatch": "^4.0.2",
+    "vue": "^3.5.17"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown"
+  }
+}