@pubinfo/vite 2.0.0-rc.1 → 2.0.0-rc.3

package/dist/index.d.ts

@@ -7,13 +7,25 @@ export * from "vite-plugin-fake-server/client";
 //#region src/plugins/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;
-  cache?: boolean;
-  maxCacheSize?: number;
 }
 //#endregion
 //#region src/interface.d.ts

package/dist/index.js

@@ -1,9 +1,9 @@
 import { createRequire } from "node:module";
-import { defineConfig, loadEnv, mergeConfig } from "rolldown-vite";
+import { defineConfig, loadEnv, mergeConfig, normalizePath } from "rolldown-vite";
 import { cwd } from "node:process";
 import chalk from "chalk";
 import consola from "consola";
-import { join, posix, relative, resolve } from "node:path";
+import { dirname, join, posix, relative, resolve } from "node:path";
 import vue from "@vitejs/plugin-vue";
 import vueJsx from "@vitejs/plugin-vue-jsx";
 import autoImport from "unplugin-auto-import/vite";
@@ -14,15 +14,18 @@ import compression from "vite-plugin-compression";
 import dts from "vite-plugin-dts";
 import Icons from "unplugin-icons/vite";
 import boxen from "boxen";
+import { libInjectCss } from "vite-plugin-lib-inject-css";
 import VueDevTools from "vite-plugin-vue-devtools";
 import vueLegacy from "@vitejs/plugin-legacy";
-import { createHash } from "node:crypto";
-import { existsSync, statSync } from "node:fs";
 import fg from "fast-glob";
 import { merge } from "lodash-es";
+import picomatch from "picomatch";
+import { existsSync } from "node:fs";
 import { vitePluginFakeServer } from "vite-plugin-fake-server";
 import OpenAPI from "@pubinfo/unplugin-openapi/vite";
 import Unocss from "unocss/vite";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 
 export * from "rolldown-vite"
 
@@ -67,17 +70,20 @@ function getServerProxy(env, isProxy) {
 //#endregion
 //#region src/plugins/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" })]
-	});
+	return {
+		...autoImport({
+			imports: [
+				"vue",
+				"vue-router",
+				"pinia",
+				{ pubinfo: ["useAuth"] }
+			],
+			ignore: ["h"],
+			dts: "./.pubinfo/auto-imports.d.ts",
+			resolvers: [AntDesignVueResolver(), IconsResolver({ prefix: "i" })]
+		}),
+		enforce: "pre"
+	};
 }
 
 //#endregion
@@ -137,10 +143,13 @@ function createCompression(env) {
 //#endregion
 //#region src/plugins/dts.ts
 function createDTS() {
-	return dts({
-		clearPureImport: false,
-		exclude: ["tests/**/*"]
-	});
+	return {
+		...dts({
+			clearPureImport: false,
+			exclude: ["tests/**/*"]
+		}),
+		enforce: "post"
+	};
 }
 
 //#endregion
@@ -191,6 +200,12 @@ function appInfo() {
 	};
 }
 
+//#endregion
+//#region src/plugins/inject-css.ts
+function createInjectCSS() {
+	return libInjectCss();
+}
+
 //#endregion
 //#region src/plugins/inspector.ts
 function createInspector(env) {
@@ -220,32 +235,70 @@ function getPatternBase(pattern) {
 	}
 	return baseParts.join("/");
 }
-function normalizePath(path) {
+function normalizePath$1(path) {
 	return posix.normalize(path.replace(/\\/g, "/"));
 }
 function libResolverPlugin(options) {
 	const virtualModuleId = "virtual:pubinfo-resolver";
 	const resolvedId = `\0${virtualModuleId}`;
-	const enableCache = options.cache ?? true;
-	const maxCacheSize = options.maxCacheSize ?? 50;
-	const cache = /* @__PURE__ */ new Map();
+	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;
+		const patterns = Object.values(options.entries);
+		const matchesPattern = patterns.some((pattern, index) => {
+			const matcher = picomatch(pattern);
+			const matches = matcher(relativePath);
+			return matches;
+		});
+		const result = matchesPattern && isVueOrTsFile;
+		return result;
+	}
 	return {
 		name: "vite-plugin-lib-resolver",
 		enforce: "pre",
-		buildStart() {
-			if (!enableCache) cache.clear();
+		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;
-			const configHash = createHash("md5").update(JSON.stringify(options.entries)).digest("hex");
-			if (enableCache && cache.has(configHash)) {
-				const cached = cache.get(configHash);
-				const hasChanges = await checkForFileChanges(options.entries, cached.fileHashes);
-				if (!hasChanges) return cached.content;
-			}
 			const moduleResults = await Promise.all(Object.entries(options.entries).map(async ([key, pattern]) => {
 				try {
 					const files = await fg(pattern, { absolute: true });
@@ -256,8 +309,8 @@ function libResolverPlugin(options) {
 					};
 					const base = getPatternBase(pattern);
 					const imports = files.map((file) => {
-						const absPath = normalizePath(file);
-						const relToBase = normalizePath(relative(resolve(base), file));
+						const absPath = normalizePath$1(file);
+						const relToBase = normalizePath$1(relative(resolve(base), file));
 						const relPath = posix.join(base, relToBase);
 						return `"${relPath}": () => import("${absPath}")`;
 					}).join(",\n");
@@ -277,57 +330,16 @@ function libResolverPlugin(options) {
 			}));
 			const moduleDefs = moduleResults.map((result) => result.content);
 			const content = `export default {\n  ${moduleDefs.join(",\n  ")}\n}`;
-			const fileHashes = /* @__PURE__ */ new Map();
-			const allFiles = moduleResults.flatMap((result) => result.files);
-			for (const file of allFiles) if (existsSync(file)) {
-				const stats = statSync(file);
-				const fileHash = createHash("md5").update(`${file}-${stats.mtimeMs}-${stats.size}`).digest("hex");
-				fileHashes.set(file, fileHash);
-			}
-			if (enableCache) {
-				if (cache.size >= maxCacheSize) {
-					const oldestKey = cache.keys().next().value;
-					if (oldestKey) cache.delete(oldestKey);
-				}
-				cache.set(configHash, {
-					content,
-					fileHashes,
-					timestamp: Date.now()
-				});
-			}
 			return content;
 		}
 	};
-	async function checkForFileChanges(entries, cachedFileHashes) {
-		try {
-			for (const pattern of Object.values(entries)) {
-				const files = await fg(pattern, { absolute: true });
-				for (const file of files) {
-					if (!existsSync(file)) return true;
-					const stats = statSync(file);
-					const currentFileHash = createHash("md5").update(`${file}-${stats.mtimeMs}-${stats.size}`).digest("hex");
-					const cachedHash = cachedFileHashes.get(file);
-					if (!cachedHash || cachedHash !== currentFileHash) return true;
-				}
-				for (const cachedFile of cachedFileHashes.keys()) if (!files.includes(cachedFile) && existsSync(cachedFile)) return true;
-			}
-			return false;
-		} catch (error) {
-			console.warn("[lib-resolver] Error checking file changes:", error);
-			return true;
-		}
-	}
 }
 function createLibResolver(options) {
-	return libResolverPlugin(merge({
-		entries: {
-			icons: "src/assets/icons/**/*",
-			layouts: "src/layouts/*.vue",
-			pages: "src/views/**/*.vue"
-		},
-		cache: true,
-		maxCacheSize: 50
-	}, options));
+	return libResolverPlugin(merge({ entries: {
+		icons: "src/assets/icons/**/*",
+		layouts: "src/layouts/*.vue",
+		pages: "src/views/**/*.vue"
+	} }, options));
 }
 
 //#endregion
@@ -355,6 +367,75 @@ function createUnocss() {
 	return Unocss();
 }
 
+//#endregion
+//#region src/plugins/virtual-inspector.ts
+function getInspectorPath() {
+	const pluginPath = normalizePath(dirname(fileURLToPath(import.meta.url)));
+	return pluginPath;
+}
+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 (importee === virtualModuleId) {
+				const resolved = resolve(inspectorPath, "load.js");
+				return resolved;
+			}
+			return null;
+		},
+		async load(id) {
+			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) 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/index.ts
 function createVitePlugins(viteEnv, isBuild = false, config, type) {
@@ -371,7 +452,8 @@ function createVitePlugins(viteEnv, isBuild = false, config, type) {
 		createOpenAPI(config.openapi),
 		createLibResolver(config.resolver),
 		appInfo(),
-		type === "module" ? [createDTS()] : null,
+		createVirtualInspector({ enabled: true }),
+		type === "module" ? [createDTS(), createInjectCSS()] : null,
 		isBuild ? createCompression(viteEnv) : null
 	];
 	return vitePlugins.filter(Boolean);

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

@@ -1,7 +1,7 @@
 {
   "name": "@pubinfo/vite",
   "type": "module",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.3",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -19,18 +19,20 @@
     "vue-i18n": "^10.0.7"
   },
   "dependencies": {
-    "@pubinfo/unplugin-openapi": "^0.8.4",
+    "@pubinfo/unplugin-openapi": "^0.9.0",
     "@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",
+    "chokidar": "^4.0.1",
     "consola": "^3.4.2",
     "fast-glob": "^3.3.3",
     "fs-extra": "^11.3.0",
     "jszip": "^3.10.1",
     "lodash-es": "^4.17.21",
+    "picomatch": "^4.0.3",
     "rolldown-vite": "^7.1.2",
     "terser": "^5.43.1",
     "unocss": "^66.4.2",
@@ -41,12 +43,14 @@
     "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/node": "^24.0.10",
+    "@types/picomatch": "^4.0.2",
     "vue": "^3.5.17",
     "vue-i18n": "^10.0.7"
   },