@pubinfo-pr/devtools 0.189.2 → 0.203.2

package/dist/index.mjs

@@ -0,0 +1,2508 @@
+import { DIR_CLIENT } from "./dirs.mjs";
+import { Buffer } from "node:buffer";
+import sirv from "sirv";
+import { basename, dirname, extname, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { arch, platform, release } from "node:os";
+import process from "node:process";
+import { Lang, parse } from "@ast-grep/napi";
+
+//#region src/server/controller/api.ts
+const REQUEST_MODULE_EXTENSIONS = [
+	".ts",
+	".mts",
+	".cts",
+	".tsx",
+	".js",
+	".mjs",
+	".cjs",
+	".jsx"
+];
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizePath(filePath) {
+	return filePath.replace(/\\/g, "/");
+}
+/**
+* 构造别名解析器集合。
+*
+* 支持以下映射：
+* - '@/x'、'~/x' → <root>/src/x
+* - tsconfig.json 中 compilerOptions.paths 定义的别名（含 * 通配符）
+*
+* 实现采用正则表驱动：传入 specifier 后逐条匹配并映射为绝对路径字符串。
+*/
+function createAliasResolver(root) {
+	const entries = [{
+		match: /^@\/(.+)$/,
+		map: (match) => join(root, "src", match[1])
+	}, {
+		match: /^~\/(.+)$/,
+		map: (match) => join(root, "src", match[1])
+	}];
+	const tsconfigCandidates = [join(root, "tsconfig.json"), join(root, "tsconfig.app.json")];
+	for (const configPath of tsconfigCandidates) {
+		if (!existsSync(configPath)) continue;
+		try {
+			const compilerOptions = JSON.parse(readFileSync(configPath, "utf-8"))?.compilerOptions ?? {};
+			const baseUrl = compilerOptions.baseUrl ? join(root, compilerOptions.baseUrl) : root;
+			const paths = compilerOptions.paths;
+			if (!paths || typeof paths !== "object") continue;
+			for (const [key, values] of Object.entries(paths)) {
+				const targets = Array.isArray(values) ? values : [values];
+				const hasWildcard = key.includes("*");
+				const pattern = new RegExp(`^${escapeRegExp(key).replace(/\\\*/g, "(.+)")}$`);
+				targets.forEach((targetPath) => {
+					if (typeof targetPath !== "string") return;
+					const normalizedTarget = targetPath.replace(/\\/g, "/");
+					entries.push({
+						match: pattern,
+						map: (match) => {
+							if (hasWildcard) {
+								const wildcard = match[1] ?? "";
+								return join(baseUrl, normalizedTarget.replace(/\*/g, wildcard));
+							}
+							return join(baseUrl, normalizedTarget);
+						}
+					});
+				});
+			}
+		} catch {}
+	}
+	return entries;
+}
+/**
+* 在若干后缀（ts/tsx/js/...）与 index 文件中尝试解析具体文件。
+*
+* - candidate 可能未带扩展名，函数会尝试附加扩展与目录下 index.xxx。
+* - 仅返回存在且确认为文件的路径；失败返回 undefined。
+*/
+function resolveWithExtensions(candidate) {
+	const candidates = [candidate];
+	if (!/\.[^/\\]+$/.test(candidate)) REQUEST_MODULE_EXTENSIONS.forEach((ext) => {
+		candidates.push(`${candidate}${ext}`);
+		candidates.push(join(candidate, `index${ext}`));
+	});
+	for (const file of candidates) if (existsSync(file)) try {
+		if (statSync(file).isFile()) return file;
+	} catch {}
+}
+/**
+* 依据导入路径与导入者位置，解析出相对于项目根目录的模块文件路径。
+*
+* 支持：
+* - 相对路径（./x、../x）
+* - 绝对路径（/x → <root>/x）
+* - 别名（来自 createAliasResolver 的 entries）
+* - 退化支持 '@/x' 或 '~/x' 当 paths 未配置但文件位于 <root>/src 下
+*/
+function resolveRequestModulePath(specifier, importerPath, root, aliasEntries) {
+	const importerDir = dirname(importerPath);
+	let absoluteCandidate;
+	if (specifier.startsWith(".")) absoluteCandidate = join(importerDir, specifier);
+	else if (specifier.startsWith("/")) absoluteCandidate = join(root, specifier.replace(/^\//, ""));
+	else for (const entry of aliasEntries) {
+		const match = entry.match.exec(specifier);
+		if (match) {
+			absoluteCandidate = entry.map(match);
+			break;
+		}
+	}
+	if (!absoluteCandidate && (specifier.startsWith("@/") || specifier.startsWith("~/"))) {
+		const markerIndex = normalizePath(importerPath).lastIndexOf("/src/");
+		if (markerIndex !== -1) absoluteCandidate = join(importerPath.slice(0, markerIndex), "src", specifier.slice(2));
+	}
+	if (!absoluteCandidate) return;
+	const resolved = resolveWithExtensions(absoluteCandidate);
+	if (!resolved) return;
+	return normalizePath(relative(root, resolved));
+}
+/**
+* 查找项目根目录的 OpenAPI 配置文件。
+*
+* 约定优于配置：默认仅查找根目录下的 `openapi.config.ts`。
+* 如需扩展为支持更多命名/位置，可在此集中改造，避免影响调用方。
+*
+* @param root 项目根目录的绝对路径（即 Vite server.config.root）
+* @returns 如果存在则返回绝对路径，否则返回 null
+*/
+async function findOpenapiConfig(root) {
+	const configPath = join(root, "openapi.config.ts");
+	if (existsSync(configPath)) return configPath;
+	return null;
+}
+/**
+* 动态加载 OpenAPI 配置文件。
+*
+* 之所以使用动态 import 而非 require：
+* - 支持 ESM 项目
+* - 避免被打包时静态分析（保持运行时可替换）
+*
+* 注意：此函数在 devtools 插件的 Vite 环境中执行，允许使用 file:// URL。
+*
+* @param configPath 配置文件的绝对路径
+* @returns 解析后的配置对象（优先使用 module.default），失败时返回 null
+*/
+async function loadOpenapiConfig(configPath) {
+	try {
+		const fileUrl = pathToFileURL(configPath).href;
+		const extension = extname(configPath);
+		if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
+			const { loadConfig } = await import("unconfig");
+			const result = await loadConfig({
+				cwd: dirname(configPath),
+				sources: [{
+					files: basename(configPath, extension),
+					extensions: [extension.slice(1)]
+				}],
+				merge: false
+			});
+			if (typeof result?.config === "undefined") return null;
+			return await Promise.resolve(result.config);
+		} else {
+			const module = await import(fileUrl);
+			return module.default || module;
+		}
+	} catch (error) {
+		console.error(`加载配置文件失败: ${error}`);
+		return null;
+	}
+}
+/**
+* 从 TypeScript 源文件内容中提取导出的 API 函数的元信息。
+*
+* 约定：
+* - 仅识别 `export function foo(...)` 的导出形式；若有 `const foo = () => {}` 请改为函数导出或扩展正则。
+* - 通过 JSDoc 约定读取三类元数据：
+*   - @description 文本说明
+*   - @url 接口路径（例如 /user/list）
+*   - @method 请求方法（GET/POST/...）
+* - 通过参数签名解析类型信息：
+*   - params: API.Xxx → 视为 query
+*   - body: API.Xxx → 视为 body
+*   - 泛型参数中的 `R = API.Xxx` → 视为返回类型
+*
+* 限制与注意：
+* - 该实现基于正则进行快速解析，无法覆盖所有 TS 语法边界；遇到复杂写法可改为 AST（ts-morph / @typescript-eslint/typescript-estree）。
+* - 若同一文件存在多种导出形式，请保持上述约定以获得稳定结果。
+*
+* @param content 源文件文本
+* @param filePath 相对于项目根目录的文件相对路径（用于展示）
+* @param requestClient 若源码中以 `import { foo as request }` 形式命名的请求实例名，用于偏好匹配应用端实例
+* @returns 解析得到的 API 函数列表
+*/
+function extractApiFunctions(content, filePath, requestClient, requestModulePath, requestModuleResolvedPath) {
+	const functions = [];
+	const functionRegex = /\/\*\*\s*\n([^*]*(?:\*(?!\/)[^*]*)*)\*\/\s*export\s+function\s+(\w+)[^(]*\(([^)]*)\)/g;
+	let match = functionRegex.exec(content);
+	while (match !== null) {
+		const [, jsdoc, functionName, params] = match;
+		const descMatch = /@description\s+(.+)/.exec(jsdoc);
+		const description = descMatch ? descMatch[1].trim() : void 0;
+		const urlMatch = /@url\s+(.+)/.exec(jsdoc);
+		const url = urlMatch ? urlMatch[1].trim() : "";
+		const methodMatch = /@method\s+(.+)/.exec(jsdoc);
+		const method = methodMatch ? methodMatch[1].trim() : "UNKNOWN";
+		let paramType;
+		let paramLocation;
+		const paramsMatch = /params:\s*(API\.\w+)/.exec(params);
+		const bodyMatch = /body:\s*(API\.\w+)/.exec(params);
+		if (paramsMatch) {
+			paramType = paramsMatch[1];
+			paramLocation = "query";
+		} else if (bodyMatch) {
+			paramType = bodyMatch[1];
+			paramLocation = "body";
+		}
+		let returnType;
+		const returnTypeMatch = /R\s*=\s*(API\.\w+)/.exec(params);
+		if (returnTypeMatch) returnType = returnTypeMatch[1];
+		functions.push({
+			name: functionName,
+			description,
+			url,
+			method,
+			file: filePath,
+			paramType,
+			paramLocation,
+			returnType,
+			requestClient,
+			requestModulePath,
+			requestModuleResolvedPath
+		});
+		match = functionRegex.exec(content);
+	}
+	return functions;
+}
+/**
+* 将 TypeScript 类型（字面量对象类型）解析为简化的 JSON Schema 片段。
+*
+* 目前仅对如下简单场景做支持：
+* - `type Xxx = { foo: string; bar?: number }`
+* - 行内 JSDoc `/** desc *\/` 写在属性前可作为 description。
+* - 属性类型仅做基础映射（string/number/boolean/Record/any/数组）
+*
+* 不支持/暂不支持：
+* - 嵌套类型、联合/交叉、索引类型、条件类型、接口继承等复杂语法。
+* - interface 的 body 解析（可按需扩展正则）。
+*
+* 若需要更完整能力，建议切换到 TS AST 或 json-schema-generator 工具链。
+*
+* @param content typings.d.ts 文件全文
+* @param typeName 形如 `API.UserQuery` 的带命名空间类型名
+* @returns 简化的 JSON Schema 对象；无法解析时返回 null
+*/
+function parseTypeToSchema(content, typeName) {
+	try {
+		const match = new RegExp(`type\\s+${typeName.split(".").pop()}\\s*=\\s*\\{([^}]*)\\}`, "s").exec(content);
+		if (!match) return null;
+		const typeBody = match[1];
+		const properties = {};
+		const required = [];
+		const lines = typeBody.split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*")) continue;
+			const propWithComment = /^\/\*\*\s*(.+?)\s*\*\/\s*(\w+)(\??):\s*(.+?);?$/.exec(trimmed);
+			const propWithoutComment = /^(\w+)(\??):\s*(.+?);?$/.exec(trimmed);
+			if (propWithComment) {
+				const [, description, propertyName, optional, propertyType] = propWithComment;
+				const isOptional = optional === "?";
+				const prop = { type: mapTsTypeToJsonType(propertyType) };
+				if (description) prop.description = description;
+				properties[propertyName] = prop;
+				if (!isOptional) required.push(propertyName);
+			} else if (propWithoutComment) {
+				const [, propertyName, optional, propertyType] = propWithoutComment;
+				const isOptional = optional === "?";
+				properties[propertyName] = { type: mapTsTypeToJsonType(propertyType) };
+				if (!isOptional) required.push(propertyName);
+			}
+		}
+		return {
+			type: "object",
+			properties,
+			required: required.length > 0 ? required : void 0
+		};
+	} catch (error) {
+		console.error(`解析类型 ${typeName} 失败:`, error);
+		return null;
+	}
+}
+/**
+* 将常见的 TypeScript 基础类型映射为 JSON Schema 的 `type`。
+*
+* @param tsType TypeScript 类型字面量（如 'string' | 'number[]' | 'Record<string, any>'）
+* @returns JSON Schema 的基础类型字符串
+*/
+function mapTsTypeToJsonType(tsType) {
+	const type = tsType.trim();
+	if (type === "string") return "string";
+	if (type === "number") return "number";
+	if (type === "boolean") return "boolean";
+	if (type === "any" || type.startsWith("Record<")) return "object";
+	if (type.endsWith("[]")) return "array";
+	return "string";
+}
+/**
+* 从 `typings.d.ts` 中提取类型清单（仅定位名称，不展开定义）。
+*
+* 约定：
+* - 在 `declare namespace Xxx { ... }` 范围内提取 `type` 与 `interface` 的标识符。
+* - 仅收集行首的声明行，记录其名称与文件路径，便于 UI 展示与 schema 进一步解析。
+*
+* @param content typings.d.ts 文件全文
+* @param filePath 相对项目根的文件路径
+* @returns 类型条目列表
+*/
+function extractTypes(content, filePath) {
+	const types = [];
+	const lines = content.split("\n");
+	let currentNamespace = "";
+	let inNamespace = false;
+	let braceCount = 0;
+	for (const line of lines) {
+		const namespaceMatch = /declare\s+namespace\s+(\w+)/.exec(line);
+		if (namespaceMatch) {
+			currentNamespace = namespaceMatch[1];
+			inNamespace = true;
+			braceCount = 0;
+		}
+		if (inNamespace) {
+			braceCount += (line.match(/\{/g) || []).length;
+			braceCount -= (line.match(/\}/g) || []).length;
+			if (braceCount === 0 && line.includes("}")) inNamespace = false;
+		}
+		if (inNamespace && currentNamespace) {
+			const typeMatch = /^\s*(type|interface)\s+(\w+)/.exec(line);
+			if (typeMatch) {
+				const typeName = typeMatch[2];
+				types.push({
+					name: `${currentNamespace}.${typeName}`,
+					file: filePath,
+					content: line.trim()
+				});
+			}
+		}
+	}
+	return types;
+}
+/**
+* 递归扫描给定目录以收集 API 函数与类型定义。
+*
+* 扫描规则：
+* - 识别 `typings.d.ts` → 提取类型并尝试为同目录的 API 函数生成参数/返回 schema。
+* - 识别 `*.ts`（排除 index.ts）→ 通过 JSDoc 与参数签名提取 API 函数信息。
+* - 递归子目录以形成模块（module.path 为相对目录）。
+*
+* @param dir 要扫描的目录绝对路径（通常来自配置的 output）
+* @param root 项目根目录绝对路径，用于计算相对路径与分组
+* @returns 模块列表，每个模块包含 functions 与 types
+*/
+async function scanApiDirectory(dir, root, aliasEntries) {
+	const modules = [];
+	if (!existsSync(dir)) return modules;
+	const entries = await readdir(dir, { withFileTypes: true });
+	let typingsContent = null;
+	for (const entry of entries) if (entry.isFile() && entry.name === "typings.d.ts") {
+		typingsContent = readFileSync(join(dir, entry.name), "utf-8");
+		break;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			const subModules = await scanApiDirectory(fullPath, root, aliasEntries);
+			modules.push(...subModules);
+		} else if (entry.isFile() && entry.name.endsWith(".ts")) {
+			const content = readFileSync(fullPath, "utf-8");
+			const relativePath = relative(root, fullPath);
+			const requestImportMatch = /import\s*\{\s*([\w$]+)\s+as\s+request\s*\}\s*from\s*['"]([^'"]+)['"]/.exec(content);
+			const requestClient = requestImportMatch ? requestImportMatch[1] : void 0;
+			const requestModulePath = requestImportMatch ? requestImportMatch[2] : void 0;
+			const requestModuleResolvedPath = requestModulePath ? resolveRequestModulePath(requestModulePath, fullPath, root, aliasEntries) : void 0;
+			if (entry.name === "typings.d.ts") {
+				const types = extractTypes(content, relativePath);
+				if (types.length > 0) {
+					const moduleDir = relative(root, dir);
+					let module = modules.find((m) => m.path === moduleDir);
+					if (!module) {
+						module = {
+							path: moduleDir,
+							functions: [],
+							types: []
+						};
+						modules.push(module);
+					}
+					module.types.push(...types);
+				}
+			} else if (entry.name !== "index.ts") {
+				const functions = extractApiFunctions(content, relativePath, requestClient, requestModulePath, requestModuleResolvedPath);
+				if (functions.length > 0) {
+					const moduleDir = relative(root, dir);
+					let module = modules.find((m) => m.path === moduleDir);
+					if (!module) {
+						module = {
+							path: moduleDir,
+							functions: [],
+							types: []
+						};
+						modules.push(module);
+					}
+					if (typingsContent) for (const func of functions) {
+						if (func.paramType) {
+							const schema = parseTypeToSchema(typingsContent, func.paramType);
+							if (schema) func.paramSchema = schema;
+						}
+						if (func.returnType) {
+							const schema = parseTypeToSchema(typingsContent, func.returnType);
+							if (schema) func.returnSchema = schema;
+						}
+					}
+					module.functions.push(...functions);
+				}
+			}
+		}
+	}
+	return modules;
+}
+/**
+* 根据 OpenAPI 配置计算需要扫描的 API 目录集合。
+*
+* 兼容策略：
+* - 当存在 `batch` 时收集每项的 `output`。
+* - 否则尝试使用顶层 `output`。
+* - 以上都不存在时，回退到默认 `src/api` 目录。
+*
+* 注意：配置中的相对路径会被解析到项目根目录下。
+*
+* @param config 解析后的 OpenAPI 配置对象（可能为 null）
+* @param root 项目根目录绝对路径
+* @returns 需要扫描的目录绝对路径数组（去重后）
+*/
+function extractApiDirectories(config, root) {
+	const directories = /* @__PURE__ */ new Set();
+	if (!config) {
+		directories.add(join(root, "src", "api"));
+		return Array.from(directories);
+	}
+	if (config.batch && Array.isArray(config.batch)) {
+		for (const item of config.batch) if (item.output) {
+			const fullPath = join(root, item.output.replace(/^\.\//, ""));
+			directories.add(fullPath);
+		}
+	}
+	if (config.output) {
+		const fullPath = join(root, config.output.replace(/^\.\//, ""));
+		directories.add(fullPath);
+	}
+	if (directories.size === 0) directories.add(join(root, "src", "api"));
+	return Array.from(directories);
+}
+/**
+* 扫描项目并返回 API 概览与配置快照。
+*
+* 执行流程：
+* 1) 在项目根查找并加载 `openapi.config.ts`（若存在）。
+* 2) 基于配置解析出需要扫描的目录（支持 batch/output）。
+* 3) 对每个目录进行递归扫描，收集 API 函数与类型信息。
+*
+* @param root 项目根目录绝对路径
+* @returns {ApiScanResult} 包含配置（可能为 null）与所有模块的扫描结果
+*/
+async function getRequestList(root) {
+	const configPath = await findOpenapiConfig(root);
+	let config = null;
+	if (configPath) config = await loadOpenapiConfig(configPath);
+	const apiDirectories = extractApiDirectories(config, root);
+	const aliasEntries = createAliasResolver(root);
+	const allModules = [];
+	for (const apiDir of apiDirectories) {
+		const modules = await scanApiDirectory(apiDir, root, aliasEntries);
+		allModules.push(...modules);
+	}
+	return {
+		config,
+		modules: allModules
+	};
+}
+
+//#endregion
+//#region src/server/controller/issue.ts
+/**
+* 安全执行 git 命令，失败时返回 null
+*/
+function execGit(command, cwd) {
+	try {
+		return execSync(command, {
+			cwd,
+			encoding: "utf-8",
+			timeout: 5e3
+		}).trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 采集 Git 信息
+*/
+function collectGitInfo(root) {
+	return {
+		userName: execGit("git config user.name", root),
+		userEmail: execGit("git config user.email", root),
+		branch: execGit("git rev-parse --abbrev-ref HEAD", root),
+		commitHash: execGit("git rev-parse --short HEAD", root),
+		remoteUrl: execGit("git remote get-url origin", root)
+	};
+}
+/**
+* 读取项目 package.json
+*/
+function collectPackageJson(root) {
+	try {
+		const pkgPath = join(root, "package.json");
+		if (!existsSync(pkgPath)) return {};
+		return JSON.parse(readFileSync(pkgPath, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+/**
+* 采集完整的环境信息
+*/
+function getEnvironmentInfo(root) {
+	return {
+		nodeVersion: process.version,
+		platform: platform(),
+		arch: arch(),
+		osVersion: release(),
+		packageJson: collectPackageJson(root),
+		git: collectGitInfo(root)
+	};
+}
+/**
+* 将环境信息格式化为 Markdown 文本，用于 Issue body
+*/
+function formatEnvironmentMarkdown(env) {
+	const envObj = {
+		node: env.nodeVersion,
+		os: `${env.platform} ${env.arch} (${env.osVersion})`,
+		git: {
+			branch: env.git.branch,
+			commit: env.git.commitHash,
+			user: env.git.userName ? `${env.git.userName}${env.git.userEmail ? ` <${env.git.userEmail}>` : ""}` : null,
+			remote: env.git.remoteUrl
+		}
+	};
+	const lines = [];
+	lines.push(`### 环境信息`);
+	lines.push("");
+	lines.push("```json");
+	lines.push(JSON.stringify(envObj, null, 2));
+	lines.push("```");
+	lines.push("");
+	lines.push(`### package.json`);
+	lines.push("");
+	lines.push("```json");
+	lines.push(JSON.stringify(env.packageJson, null, 2));
+	lines.push("```");
+	return lines.join("\n");
+}
+/**
+* 将表单数据格式化为 Issue body（Markdown）
+*/
+function formatIssueBody(body, environment) {
+	const sections = [];
+	sections.push(`## 问题描述`);
+	sections.push(body.description || "_未填写_");
+	sections.push("");
+	if (body.steps) {
+		sections.push(`## 复现步骤`);
+		sections.push(body.steps);
+		sections.push("");
+	}
+	if (body.expected) {
+		sections.push(`## 期望行为`);
+		sections.push(body.expected);
+		sections.push("");
+	}
+	if (body.actual) {
+		sections.push(`## 实际行为`);
+		sections.push(body.actual);
+		sections.push("");
+	}
+	sections.push(formatEnvironmentMarkdown(environment));
+	return sections.join("\n");
+}
+/**
+* 处理 Issue 提交，采集环境信息后转发到 issue.elonehoo.cn
+*/
+async function submitIssue(root, body) {
+	const issueBody = formatIssueBody(body, getEnvironmentInfo(root));
+	const response = await fetch("https://issue.elonehoo.cn/issue", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: `[Bug] ${body.title}`,
+			body: issueBody
+		})
+	});
+	if (!response.ok) throw new Error(`Issue API responded with ${response.status}: ${response.statusText}`);
+	const result = await response.json();
+	if (!result.success) throw new Error("Issue API returned success: false");
+	return result;
+}
+
+//#endregion
+//#region src/@data/pubinfo.ts
+const pubinfoImport = [
+	{
+		type: "import",
+		name: "createPubinfoProvider",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	},
+	{
+		type: "import",
+		name: "pubinfoInjectionKey",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	},
+	{
+		type: "import",
+		name: "createPubinfoContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "usePubinfoContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "createContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "createRawContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "createPubinfo",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	},
+	{
+		type: "import",
+		name: "createRequest",
+		package: "pubinfo-pr",
+		meta: { category: "request" }
+	},
+	{
+		type: "import",
+		name: "defineIconModule",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "defineRouteModule",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "getAllIconModules",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "getAllRouteModules",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "readProjectModules",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "updateWatermark",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "cleanup",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "cleanupWithoutUser",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "wrapProxy",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "watchDiffObject",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "clearPersistedState",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "getPersistedState",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "setPersistedState",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "storage",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "getPubinfoNamespace",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "publicKeyEncryption",
+		package: "pubinfo-pr",
+		meta: { category: "crypto" }
+	},
+	{
+		type: "import",
+		name: "useAuth",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useError",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useSuccess",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useWarn",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useInfo",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useStart",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useBox",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "usePartyLogin",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useTheme",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "createLog",
+		package: "pubinfo-pr",
+		meta: { category: "log" }
+	},
+	{
+		type: "import",
+		name: "defineSystemRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "getSystemRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "defineAsyncRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "getAsyncRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "formatBackRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "filterEmptyComponentRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "defineSettings",
+		package: "pubinfo-pr",
+		meta: { category: "settings" }
+	},
+	{
+		type: "import",
+		name: "getSettings",
+		package: "pubinfo-pr",
+		meta: { category: "settings" }
+	},
+	{
+		type: "import",
+		name: "useFavoritesStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useIframeStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useKeepAliveStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useMenuStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useRouteStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useSettingsStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useTabbarStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useUserStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	}
+];
+const pubinfoComponent = [
+	{
+		type: "component",
+		name: "PubinfoDev",
+		package: "pubinfo-pr",
+		meta: { category: "dev" }
+	},
+	{
+		type: "component",
+		name: "Copyright",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Layout",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutHeader",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutContent",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutProvider",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutSidebar",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutTopbar",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Logo",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "NotAllowed",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Tool",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Tools",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "PageHeader",
+		package: "pubinfo-pr",
+		meta: { category: "page" }
+	},
+	{
+		type: "component",
+		name: "PageMain",
+		package: "pubinfo-pr",
+		meta: { category: "page" }
+	},
+	{
+		type: "component",
+		name: "PartyLoginModal",
+		package: "pubinfo-pr",
+		meta: { category: "auth" }
+	},
+	{
+		type: "component",
+		name: "PassStrengthValidator",
+		package: "pubinfo-pr",
+		meta: { category: "auth" }
+	},
+	{
+		type: "component",
+		name: "PubinfoApp",
+		package: "pubinfo-pr",
+		meta: { category: "core" }
+	},
+	{
+		type: "component",
+		name: "PubinfoIcon",
+		package: "pubinfo-pr",
+		meta: { category: "icon" }
+	},
+	{
+		type: "component",
+		name: "PubinfoIconPrismBox",
+		package: "pubinfo-pr",
+		meta: { category: "icon" }
+	},
+	{
+		type: "component",
+		name: "PubinfoIconSquareBox",
+		package: "pubinfo-pr",
+		meta: { category: "icon" }
+	},
+	{
+		type: "component",
+		name: "PubinfoProvider",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	}
+];
+
+//#endregion
+//#region src/@data/vue.ts
+const VUE_DOCS_BASE = "https://cn.vuejs.org/api";
+const vueImport = [
+	{
+		type: "import",
+		name: "onActivated",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onactivated`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onBeforeMount",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onbeforemount`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onBeforeUnmount",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onbeforeunmount`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onBeforeUpdate",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onbeforeupdate`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onErrorCaptured",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onerrorcaptured`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onDeactivated",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#ondeactivated`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onMounted",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onmounted`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onServerPrefetch",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onserverprefetch`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onUnmounted",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onunmounted`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onUpdated",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onupdated`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "useAttrs",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#useattrs`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "useSlots",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#useslots`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "computed",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#computed`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "customRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#customref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isReadonly",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isreadonly`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isShallow",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isshallow`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isProxy",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isproxy`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isReactive",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isreactive`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "markRaw",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#markraw`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "reactive",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#reactive`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "readonly",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#readonly`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "ref",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#ref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "shallowReactive",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#shallowreactive`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "shallowReadonly",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#shallowreadonly`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "shallowRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#shallowref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "triggerRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#triggerref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toRaw",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#toraw`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#toref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toRefs",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#torefs`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toValue",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#tovalue`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "unref",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#unref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watch",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watch`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watchEffect",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watcheffect`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watchPostEffect",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watchposteffect`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watchSyncEffect",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watchsynceffect`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "defineComponent",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/general.html#definecomponent`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "defineAsyncComponent",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/general.html#defineasynccomponent`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "getCurrentInstance",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#getcurrentinstance`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "h",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/render-function.html#h`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "inject",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-dependency-injection.html#inject`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "nextTick",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/general.html#nexttick`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "provide",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-dependency-injection.html#provide`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "useCssModule",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/sfc-css-features.html#css-modules`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "createApp",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/application.html#createapp`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "effectScope",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#effectscope`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "EffectScope",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#effectscope`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "getCurrentScope",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#getcurrentscope`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "onScopeDispose",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#onscopedispose`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "onRenderTracked",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onrendertracked`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onRenderTriggered",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onrendertriggered`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "resolveComponent",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/render-function.html#resolvecomponent`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "useCssVars",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/sfc-css-features.html#v-bind-in-css`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "useModel",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#usemodel`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "getCurrentWatcher",
+		package: "vue",
+		meta: { category: "reactivity" }
+	},
+	{
+		type: "import",
+		name: "onWatcherCleanup",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#onwatchercleanup`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "useId",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#useid`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "useTemplateRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#usetemplateref`,
+			category: "helper"
+		}
+	}
+];
+const vueComponent = [
+	{
+		type: "component",
+		name: "Transition",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#transition` }
+	},
+	{
+		type: "component",
+		name: "TransitionGroup",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#transitiongroup` }
+	},
+	{
+		type: "component",
+		name: "KeepAlive",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#keepalive` }
+	},
+	{
+		type: "component",
+		name: "Teleport",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#teleport` }
+	},
+	{
+		type: "component",
+		name: "Suspense",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#suspense` }
+	}
+];
+
+//#endregion
+//#region src/@data/index.ts
+const functions = [...vueImport, ...pubinfoImport];
+const components = [...vueComponent, ...pubinfoComponent];
+
+//#endregion
+//#region src/server/utils/ast-analyzer.ts
+/** 跳过的目录 */
+const IGNORED_DIRS = new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".git",
+	"coverage",
+	".pubinfo"
+]);
+/** 默认源码扩展名 */
+const SOURCE_EXTENSIONS$2 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]);
+/** 单次并发读取文件数（防止文件描述符爆满） */
+const FILE_READ_CONCURRENCY = 64;
+/**
+* 递归扫描目录获取所有源文件（同步版本，保留给 module-counter 使用）
+*/
+function getAllSourceFiles(dir, extensions = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]) {
+	const extSet = new Set(extensions);
+	const files = [];
+	function scan(currentDir) {
+		try {
+			const entries = readdirSync(currentDir);
+			for (const entry of entries) {
+				const fullPath = join(currentDir, entry);
+				try {
+					const s = statSync(fullPath);
+					if (s.isDirectory()) {
+						if (!IGNORED_DIRS.has(entry)) scan(fullPath);
+					} else if (s.isFile() && extSet.has(extname(fullPath))) files.push(fullPath);
+				} catch {}
+			}
+		} catch {}
+	}
+	scan(dir);
+	return files;
+}
+/**
+* 异步递归扫描目录获取所有源文件
+*/
+async function getAllSourceFilesAsync(dir) {
+	const files = [];
+	async function scan(currentDir) {
+		let entries;
+		try {
+			entries = await readdir(currentDir);
+		} catch {
+			return;
+		}
+		const statJobs = entries.map(async (entry) => {
+			const fullPath = join(currentDir, entry);
+			try {
+				const s = await stat(fullPath);
+				if (s.isDirectory()) {
+					if (!IGNORED_DIRS.has(entry)) await scan(fullPath);
+				} else if (s.isFile() && SOURCE_EXTENSIONS$2.has(extname(fullPath))) files.push(fullPath);
+			} catch {}
+		});
+		await Promise.all(statJobs);
+	}
+	await scan(dir);
+	return files;
+}
+/**
+* 根据文件扩展名选择语言类型
+*/
+function getLang(filePath) {
+	switch (extname(filePath)) {
+		case ".tsx":
+		case ".jsx": return Lang.Tsx;
+		case ".js": return Lang.JavaScript;
+		default: return Lang.TypeScript;
+	}
+}
+/**
+* 在文件内容上做一次快速字符串检查，返回内容中可能出现的追踪项名称集合。
+* 通过这一步可以跳过绝大部分不相关的文件，避免无效 AST 解析。
+*/
+function quickFilterNames(content, names) {
+	const hits = /* @__PURE__ */ new Set();
+	for (const name of names) if (content.includes(name)) hits.add(name);
+	return hits;
+}
+/**
+* 对单个文件做一次性全量分析，返回该文件中出现的所有追踪名的使用位置。
+*
+* 优化点：
+* 1. 先用字符串 includes 快速预过滤，跳过不相关名称。
+* 2. AST 只解析一次，遍历一次 rootNode，收集所有 call_expression / import_specifier / jsx。
+* 3. Vue template 部分改为一次性合并正则匹配（而非 N 次独立正则）。
+*/
+function analyzeFile(content, filePath, functionNames, componentNames) {
+	const result = {
+		functions: /* @__PURE__ */ new Map(),
+		components: /* @__PURE__ */ new Map()
+	};
+	const hitFunctions = quickFilterNames(content, functionNames);
+	const hitComponents = quickFilterNames(content, componentNames);
+	if (hitFunctions.size === 0 && hitComponents.size === 0) return result;
+	try {
+		const rootNode = parse(getLang(filePath), content).root();
+		if (hitFunctions.size > 0) {
+			const callMatches = rootNode.findAll({ rule: { kind: "call_expression" } });
+			for (const match of callMatches) {
+				const calleeName = match.field("function")?.text();
+				if (calleeName && hitFunctions.has(calleeName)) {
+					const range = match.range();
+					const loc = {
+						file: filePath,
+						line: range.start.line + 1,
+						column: range.start.column + 1,
+						code: match.text().slice(0, 100)
+					};
+					if (!result.functions.has(calleeName)) result.functions.set(calleeName, []);
+					result.functions.get(calleeName).push(loc);
+				}
+			}
+		}
+		if (hitComponents.size > 0) {
+			const jsxMatches = rootNode.findAll({ rule: { kind: "jsx_opening_element" } });
+			for (const match of jsxMatches) {
+				const text = match.text();
+				const nameMatch = text.match(/^<(\w+)/);
+				if (nameMatch && hitComponents.has(nameMatch[1])) {
+					const compName = nameMatch[1];
+					const range = match.range();
+					const loc = {
+						file: filePath,
+						line: range.start.line + 1,
+						column: range.start.column + 1,
+						code: text.slice(0, 100)
+					};
+					if (!result.components.has(compName)) result.components.set(compName, []);
+					result.components.get(compName).push(loc);
+				}
+			}
+		}
+	} catch {}
+	if (filePath.endsWith(".vue") && hitComponents.size > 0) {
+		const names = Array.from(hitComponents);
+		const unionRegex = new RegExp(`<(${names.map(escapeRegex).join("|")})[\\s>/]`, "g");
+		const lines = content.split("\n");
+		const lineOffsets = buildLineOffsets(lines);
+		let match = unionRegex.exec(content);
+		while (match !== null) {
+			const compName = match[1];
+			const pos = match.index;
+			const lineNum = findLineNumber(lineOffsets, pos);
+			const loc = {
+				file: filePath,
+				line: lineNum,
+				column: pos - lineOffsets[lineNum - 1] + 1,
+				code: lines[lineNum - 1].trim().slice(0, 100)
+			};
+			if (!result.components.has(compName)) result.components.set(compName, []);
+			result.components.get(compName).push(loc);
+			match = unionRegex.exec(content);
+		}
+	}
+	return result;
+}
+/** 转义正则特殊字符 */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** 构建每行起始偏移量数组，索引 0 = 第 1 行起始偏移 */
+function buildLineOffsets(lines) {
+	const offsets = Array.from({ length: lines.length });
+	offsets[0] = 0;
+	for (let i = 1; i < lines.length; i++) offsets[i] = offsets[i - 1] + lines[i - 1].length + 1;
+	return offsets;
+}
+/** 通过二分查找快速定位字符偏移所在的行号（1-based） */
+function findLineNumber(lineOffsets, pos) {
+	let lo = 0;
+	let hi = lineOffsets.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (lineOffsets[mid] <= pos) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo + 1;
+}
+/**
+* 以指定并发度分批执行异步任务
+*/
+async function processBatched(items, concurrency, fn) {
+	const results = [];
+	for (let i = 0; i < items.length; i += concurrency) {
+		const batch = items.slice(i, i + concurrency);
+		const batchResults = await Promise.all(batch.map(fn));
+		results.push(...batchResults);
+	}
+	return results;
+}
+/**
+* 扫描单个文件的使用情况。用于增量更新场景。
+*/
+async function scanSingleFile(filePath, functionsToTrack, componentsToTrack) {
+	const ext = extname(filePath);
+	if (!SOURCE_EXTENSIONS$2.has(ext)) return null;
+	try {
+		return analyzeFile(await readFile(filePath, "utf-8"), filePath, new Set(functionsToTrack.map((f) => f.name)), new Set(componentsToTrack.map((c) => c.name)));
+	} catch {
+		return null;
+	}
+}
+/**
+* 扫描项目中的使用情况（优化版）
+*
+* 相比旧版的优化：
+* 1. 异步 I/O + 并发读取文件，不阻塞 Vite dev server。
+* 2. 每文件只做一次 AST 解析，遍历一次收集所有命中。
+* 3. 快速预过滤（string.includes）跳过不相关文件。
+* 4. Vue template 使用联合正则一次匹配，二分法定位行号。
+*
+* @param projectRoot 项目根目录
+* @param functionsToTrack 要追踪的函数列表
+* @param componentsToTrack 要追踪的组件列表
+*/
+async function scanUsageStats(projectRoot, functionsToTrack, componentsToTrack) {
+	const result = {
+		functions: [],
+		components: [],
+		totalFiles: 0,
+		scannedFiles: 0
+	};
+	const files = await getAllSourceFilesAsync(projectRoot);
+	result.totalFiles = files.length;
+	const functionNames = new Set(functionsToTrack.map((f) => f.name));
+	const componentNames = new Set(componentsToTrack.map((c) => c.name));
+	const functionStatsMap = /* @__PURE__ */ new Map();
+	const componentStatsMap = /* @__PURE__ */ new Map();
+	for (const func of functionsToTrack) functionStatsMap.set(func.name, {
+		name: func.name,
+		type: "import",
+		package: func.package,
+		count: 0,
+		locations: [],
+		meta: func.meta
+	});
+	for (const comp of componentsToTrack) componentStatsMap.set(comp.name, {
+		name: comp.name,
+		type: "component",
+		package: comp.package,
+		count: 0,
+		locations: [],
+		meta: comp.meta
+	});
+	await processBatched(files, FILE_READ_CONCURRENCY, async (file) => {
+		try {
+			const content = await readFile(file, "utf-8");
+			result.scannedFiles++;
+			const analysis = analyzeFile(content, file, functionNames, componentNames);
+			for (const [name, locations] of analysis.functions) {
+				const stats = functionStatsMap.get(name);
+				if (stats) {
+					stats.locations.push(...locations);
+					stats.count += locations.length;
+				}
+			}
+			for (const [name, locations] of analysis.components) {
+				const stats = componentStatsMap.get(name);
+				if (stats) {
+					stats.locations.push(...locations);
+					stats.count += locations.length;
+				}
+			}
+		} catch {}
+	});
+	result.functions = Array.from(functionStatsMap.values());
+	result.components = Array.from(componentStatsMap.values());
+	return result;
+}
+
+//#endregion
+//#region src/server/utils/module-counter.ts
+/**
+* 统计项目中通过 createPubinfo 注册的模块数量。
+*
+* 解析项目里的所有源文件，查找 createPubinfo 调用，并分析其 options.modules
+* 字段（含本地变量引用与展开语法）来估算注册的模块个数。
+*/
+function countRegisteredModules(projectRoot) {
+	const files = getAllSourceFiles(projectRoot);
+	let totalModules = 0;
+	for (const filePath of files) {
+		let content;
+		try {
+			content = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		if (!content.includes("createPubinfo")) continue;
+		try {
+			const rootNode = parse(getLang(filePath), content).root();
+			const context = {
+				rootNode,
+				initializerCache: /* @__PURE__ */ new Map()
+			};
+			const callExpressions = rootNode.findAll({ rule: { kind: "call_expression" } });
+			for (const call of callExpressions) {
+				if (!isCreatePubinfoCall(call)) continue;
+				totalModules += extractModulesFromCall(call, context);
+			}
+		} catch {
+			continue;
+		}
+	}
+	return totalModules;
+}
+function isCreatePubinfoCall(callNode) {
+	const name = callNode.field("function")?.text() ?? "";
+	return name === "createPubinfo" || name.endsWith(".createPubinfo");
+}
+function extractModulesFromCall(callNode, context) {
+	const optionsNode = resolveOptionsObject(callNode, context);
+	if (!optionsNode) return 0;
+	const modulesPair = findModulesPair(optionsNode);
+	if (!modulesPair) return 0;
+	const valueNode = modulesPair.field("value");
+	if (!valueNode) return 0;
+	return countModulesFromValue(valueNode, context, /* @__PURE__ */ new Set());
+}
+function resolveOptionsObject(callNode, context) {
+	const argsNode = callNode.field("arguments");
+	if (!argsNode) return null;
+	const directObject = argsNode.children().find((child) => child.kind() === "object");
+	if (directObject) return directObject;
+	const firstArg = getFirstNamedChild(argsNode);
+	if (firstArg?.kind() === "identifier") {
+		const initializer = findInitializer(context, firstArg.text());
+		if (initializer?.kind() === "object") return initializer;
+	}
+	return null;
+}
+function findModulesPair(objectNode) {
+	const pairs = objectNode.children().filter((child) => child.kind() === "pair");
+	for (const pair of pairs) {
+		const key = pair.field("key");
+		if ((key ? normalizeKeyText(key.text()) : null) === "modules") return pair;
+	}
+	return null;
+}
+function normalizeKeyText(raw) {
+	if (raw.startsWith("'") || raw.startsWith("\"") || raw.startsWith("`")) return raw.slice(1, -1);
+	return raw;
+}
+function countModulesFromValue(valueNode, context, visited) {
+	switch (valueNode.kind()) {
+		case "array": return countArrayEntries(valueNode, context, visited);
+		case "identifier": return countIdentifierReference(valueNode.text(), context, visited);
+		case "parenthesized_expression":
+		case "as_expression":
+		case "type_assertion":
+		case "non_null_expression": {
+			const inner = getFirstNamedChild(valueNode);
+			return inner ? countModulesFromValue(inner, context, visited) : 0;
+		}
+		default: return 0;
+	}
+}
+function countArrayEntries(arrayNode, context, visited) {
+	let count = 0;
+	for (const child of arrayNode.children()) {
+		if (!child.isNamed()) continue;
+		if (child.kind() === "spread_element") {
+			const spreadTarget = getFirstNamedChild(child);
+			if (spreadTarget) count += countModulesFromValue(spreadTarget, context, visited);
+			continue;
+		}
+		count += 1;
+	}
+	return count;
+}
+function countIdentifierReference(identifierName, context, visited) {
+	if (!identifierName || visited.has(identifierName)) return 0;
+	visited.add(identifierName);
+	const initializer = findInitializer(context, identifierName);
+	let result = 0;
+	if (initializer) result = countModulesFromValue(initializer, context, visited);
+	visited.delete(identifierName);
+	return result;
+}
+function findInitializer(context, identifierName) {
+	if (context.initializerCache.has(identifierName)) return context.initializerCache.get(identifierName) ?? null;
+	let found = null;
+	const stack = [context.rootNode];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node.kind() === "variable_declarator") {
+			if (node.field("name")?.text() === identifierName) {
+				const valueNode = node.field("value");
+				if (valueNode) {
+					found = valueNode;
+					break;
+				}
+			}
+		}
+		stack.push(...node.children());
+	}
+	context.initializerCache.set(identifierName, found);
+	return found;
+}
+function getFirstNamedChild(node) {
+	for (const child of node.children()) if (child.isNamed()) return child;
+	return null;
+}
+
+//#endregion
+//#region src/server/controller/usage.ts
+/** 源码扩展名集合，用于判断文件变更是否需要触发增量更新 */
+const SOURCE_EXTENSIONS$1 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]);
+let _cache = null;
+let _scanPromise = null;
+/**
+* 获取或初始化缓存。
+* 多个并发请求只会触发一次扫描（Promise 去重）。
+*/
+async function getOrCreateCache(projectRoot) {
+	if (_cache) return _cache;
+	if (_scanPromise) return _scanPromise;
+	_scanPromise = (async () => {
+		const stats = await scanUsageStats(projectRoot, functions, components);
+		_cache = {
+			stats,
+			fileHits: buildFileHitsIndex(stats),
+			timestamp: Date.now()
+		};
+		_scanPromise = null;
+		return _cache;
+	})();
+	return _scanPromise;
+}
+/**
+* 从扫描结果构建 "文件 → 命中" 索引，用于增量更新时快速清除旧数据。
+*/
+function buildFileHitsIndex(stats) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of stats.functions) for (const loc of item.locations) {
+		if (!map.has(loc.file)) map.set(loc.file, {
+			functions: /* @__PURE__ */ new Map(),
+			components: /* @__PURE__ */ new Map()
+		});
+		const entry = map.get(loc.file);
+		entry.functions.set(item.name, (entry.functions.get(item.name) ?? 0) + 1);
+	}
+	for (const item of stats.components) for (const loc of item.locations) {
+		if (!map.has(loc.file)) map.set(loc.file, {
+			functions: /* @__PURE__ */ new Map(),
+			components: /* @__PURE__ */ new Map()
+		});
+		const entry = map.get(loc.file);
+		entry.components.set(item.name, (entry.components.get(item.name) ?? 0) + 1);
+	}
+	return map;
+}
+/**
+* 增量更新：当单个文件发生变更时，只重新扫描该文件。
+*
+* 流程：
+* 1. 从缓存中清除该文件的旧贡献值。
+* 2. 重新扫描该文件。
+* 3. 把新结果合并回缓存。
+*/
+async function incrementalUpdate(filePath) {
+	if (!_cache) return;
+	const ext = extname(filePath);
+	if (!SOURCE_EXTENSIONS$1.has(ext)) return;
+	const { stats, fileHits } = _cache;
+	const oldEntry = fileHits.get(filePath);
+	if (oldEntry) {
+		for (const [name, count] of oldEntry.functions) {
+			const item = stats.functions.find((f) => f.name === name);
+			if (item) {
+				item.count -= count;
+				item.locations = item.locations.filter((loc) => loc.file !== filePath);
+			}
+		}
+		for (const [name, count] of oldEntry.components) {
+			const item = stats.components.find((c) => c.name === name);
+			if (item) {
+				item.count -= count;
+				item.locations = item.locations.filter((loc) => loc.file !== filePath);
+			}
+		}
+		fileHits.delete(filePath);
+	}
+	const result = await scanSingleFile(filePath, functions, components);
+	if (!result) return;
+	const newEntry = {
+		functions: /* @__PURE__ */ new Map(),
+		components: /* @__PURE__ */ new Map()
+	};
+	for (const [name, locations] of result.functions) {
+		const item = stats.functions.find((f) => f.name === name);
+		if (item) {
+			item.locations.push(...locations);
+			item.count += locations.length;
+		}
+		newEntry.functions.set(name, locations.length);
+	}
+	for (const [name, locations] of result.components) {
+		const item = stats.components.find((c) => c.name === name);
+		if (item) {
+			item.locations.push(...locations);
+			item.count += locations.length;
+		}
+		newEntry.components.set(name, locations.length);
+	}
+	if (newEntry.functions.size > 0 || newEntry.components.size > 0) fileHits.set(filePath, newEntry);
+	_cache.timestamp = Date.now();
+}
+/**
+* 增量删除：当文件被删除时，清除其贡献。
+*/
+async function incrementalRemove(filePath) {
+	if (!_cache) return;
+	const { stats, fileHits } = _cache;
+	const oldEntry = fileHits.get(filePath);
+	if (!oldEntry) return;
+	for (const [name, count] of oldEntry.functions) {
+		const item = stats.functions.find((f) => f.name === name);
+		if (item) {
+			item.count -= count;
+			item.locations = item.locations.filter((loc) => loc.file !== filePath);
+		}
+	}
+	for (const [name, count] of oldEntry.components) {
+		const item = stats.components.find((c) => c.name === name);
+		if (item) {
+			item.count -= count;
+			item.locations = item.locations.filter((loc) => loc.file !== filePath);
+		}
+	}
+	fileHits.delete(filePath);
+	_cache.timestamp = Date.now();
+}
+/**
+* 将 PascalCase/CamelCase 名称转换为 kebab-case（用于搜索匹配）
+*/
+function toKebabCase(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+/**
+* 获取 Overview 数据
+* 返回项目中实际使用的 functions 和 components（仅 count > 0）
+*/
+async function getOverview(projectRoot) {
+	const stats = (await getOrCreateCache(projectRoot)).stats;
+	const apiMethodCount = (await getRequestList(projectRoot)).modules.reduce((total, module) => {
+		return total + module.functions.length;
+	}, 0);
+	const moduleCount = countRegisteredModules(projectRoot);
+	return {
+		functions: stats.functions.filter((item) => item.count > 0),
+		components: stats.components.filter((item) => item.count > 0),
+		totalFiles: stats.totalFiles,
+		scannedFiles: stats.scannedFiles,
+		apiMethodCount,
+		moduleCount
+	};
+}
+/**
+* 获取完整的使用统计数据
+* 返回所有追踪项的使用情况（包括未使用的 count = 0）
+*/
+async function getUsageStats(projectRoot) {
+	return (await getOrCreateCache(projectRoot)).stats;
+}
+/**
+* 获取组件使用详情，附带统计摘要
+*/
+async function getComponentUsage(projectRoot) {
+	const componentsWithMeta = (await getOrCreateCache(projectRoot)).stats.components.map((component) => {
+		const dependents = Array.from(new Set(component.locations.map((location) => location.file))).sort();
+		const componentFilePath = component.locations[0]?.file;
+		return {
+			...component,
+			pascalName: component.name,
+			kebabName: toKebabCase(component.name),
+			filePath: componentFilePath,
+			dependents,
+			dependencies: []
+		};
+	});
+	const used = componentsWithMeta.filter((item) => item.count > 0).length;
+	return {
+		components: componentsWithMeta,
+		stats: {
+			total: componentsWithMeta.length,
+			used,
+			unused: componentsWithMeta.length - used
+		}
+	};
+}
+/**
+* 获取 Import/Hook 使用详情，附带统计摘要
+*/
+async function getImportUsage(projectRoot) {
+	const importsWithMeta = (await getOrCreateCache(projectRoot)).stats.functions.map((importItem) => {
+		const dependents = Array.from(new Set(importItem.locations.map((location) => location.file))).sort();
+		const importFilePath = importItem.locations[0]?.file;
+		return {
+			...importItem,
+			camelName: importItem.name,
+			filePath: importFilePath,
+			dependents
+		};
+	});
+	const used = importsWithMeta.filter((item) => item.count > 0).length;
+	return {
+		imports: importsWithMeta,
+		stats: {
+			total: importsWithMeta.length,
+			used,
+			unused: importsWithMeta.length - used
+		}
+	};
+}
+
+//#endregion
+//#region src/server/controller/version.ts
+/**
+* 从 node_modules 中查找实际安装的包版本
+* 这比从 package.json 读取更准确，因为反映了实际安装的版本
+*/
+function findPackageVersion(root, packageName) {
+	try {
+		const nodeModulesPath = join(root, "node_modules", packageName, "package.json");
+		if (!existsSync(nodeModulesPath)) {
+			const parentNodeModulesPath = join(root, "..", "node_modules", packageName, "package.json");
+			if (!existsSync(parentNodeModulesPath)) return null;
+			return JSON.parse(readFileSync(parentNodeModulesPath, "utf-8")).version || null;
+		}
+		return JSON.parse(readFileSync(nodeModulesPath, "utf-8")).version || null;
+	} catch (error) {
+		console.error(`Error reading package version from node_modules: ${error}`);
+		return null;
+	}
+}
+/**
+* 从 fast-npm-meta 服务获取包的最新版本
+*/
+async function fetchLatestVersion(packageName) {
+	try {
+		const response = await fetch(`https://npm.elonehoo.cn/${packageName}`);
+		if (!response.ok) {
+			console.error(`Failed to fetch package info: ${response.status} ${response.statusText}`);
+			return null;
+		}
+		return (await response.json()).version || null;
+	} catch (error) {
+		console.error(`Error fetching latest version from npm meta service: ${error}`);
+		return null;
+	}
+}
+/**
+* 比较两个语义化版本号
+* 返回 true 如果 current 版本低于 latest 版本
+*/
+function isOutdated(current, latest) {
+	if (!current || !latest) return false;
+	try {
+		const currentParts = current.split(".").map(Number);
+		const latestParts = latest.split(".").map(Number);
+		for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+			const currentPart = currentParts[i] || 0;
+			const latestPart = latestParts[i] || 0;
+			if (currentPart < latestPart) return true;
+			if (currentPart > latestPart) return false;
+		}
+		return false;
+	} catch (error) {
+		console.error(`Error comparing versions: ${error}`);
+		return false;
+	}
+}
+/**
+* 获取包的版本信息
+*/
+async function getPackageVersion(root, packageName) {
+	try {
+		if (!packageName || typeof packageName !== "string") return {
+			packageName: packageName || "",
+			currentVersion: null,
+			latestVersion: null,
+			isOutdated: false,
+			error: "Package name is required"
+		};
+		const currentVersion = findPackageVersion(root, packageName);
+		const latestVersion = await fetchLatestVersion(packageName);
+		return {
+			packageName,
+			currentVersion,
+			latestVersion,
+			isOutdated: isOutdated(currentVersion, latestVersion)
+		};
+	} catch (error) {
+		return {
+			packageName,
+			currentVersion: null,
+			latestVersion: null,
+			isOutdated: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+
+//#endregion
+//#region src/server/index.ts
+/**
+* Pubinfo Devtools 的 Vite 插件入口。
+*
+* 能力概览：
+* - 提供一个轻量 UI（iframe）静态资源服务：`/__pubinfo_devtools`。
+* - 提供 devtools 专用的 API：`/__pubinfo_devtools_api`。
+*   - `/overview` → 返回项目中实际使用的方法和组件。
+*   - `/usage-stats` → 返回完整使用统计。
+*   - `/component-usage` → 返回组件使用详情。
+*   - `/import-usage` → 返回 Import/Hook 使用详情。
+*   - `/api-list` → 返回解析的 OpenAPI 配置与扫描到的 API 函数/类型清单。
+*   - `/package-version` → 返回包版本信息。
+*
+* 性能优化：
+* - 首次请求时执行全量扫描并缓存结果。
+* - 借助 Vite watcher 监听文件变化，仅对变更文件做增量更新。
+* - 所有 API 共享同一份缓存，避免重复扫描。
+* - JSON 响应不做美化格式化（减少 ~30% 体积）。
+*
+* 注意：本插件默认以 `enforce: 'pre'` 注入，避免被其他中间件拦截。
+* 路由均在开发服务器中间件阶段生效，不影响生产构建输出。
+*
+* 安全说明：这些接口仅用于本地开发环境调试，不应暴露到公网。
+*/
+/** 源码文件扩展名，与 ast-analyzer 保持一致 */
+const SOURCE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]);
+function isSourceFile(path) {
+	const dot = path.lastIndexOf(".");
+	return dot !== -1 && SOURCE_EXTENSIONS.has(path.slice(dot));
+}
+function pubinfoDevtools() {
+	return {
+		name: "vite-plugin-pubinfo-devtools",
+		enforce: "pre",
+		configureServer(server) {
+			const baseURL = "__pubinfo_devtools";
+			server.watcher.on("change", (filePath) => {
+				if (isSourceFile(filePath)) incrementalUpdate(filePath).catch(() => {});
+			});
+			server.watcher.on("add", (filePath) => {
+				if (isSourceFile(filePath)) incrementalUpdate(filePath).catch(() => {});
+			});
+			server.watcher.on("unlink", (filePath) => {
+				if (isSourceFile(filePath)) incrementalRemove(filePath).catch(() => {});
+			});
+			server.middlewares.use(`/${baseURL}`, sirv(DIR_CLIENT, {
+				single: true,
+				dev: true
+			}));
+			server.middlewares.use(`/${baseURL}_api`, async (req, res, next) => {
+				if (!req.url) return next();
+				if (req.url === "/overview") {
+					try {
+						sendJSON(res, await getOverview(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get overview data", error);
+					}
+					return;
+				}
+				if (req.url === "/usage-stats") {
+					try {
+						sendJSON(res, await getUsageStats(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get usage statistics", error);
+					}
+					return;
+				}
+				if (req.url === "/component-usage") {
+					try {
+						sendJSON(res, await getComponentUsage(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get component usage", error);
+					}
+					return;
+				}
+				if (req.url === "/import-usage") {
+					try {
+						sendJSON(res, await getImportUsage(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get import usage", error);
+					}
+					return;
+				}
+				if (req.url.startsWith("/api-list")) {
+					try {
+						sendJSON(res, await getRequestList(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get API list", error);
+					}
+					return;
+				}
+				if (req.url.startsWith("/package-version")) {
+					try {
+						const packageName = new URLSearchParams(req.url.slice(16)).get("package") || "";
+						if (!packageName) {
+							res.statusCode = 400;
+							sendJSON(res, {
+								error: "Missing package parameter",
+								message: "Please provide a package name using ?package=<package-name>"
+							});
+							return;
+						}
+						sendJSON(res, await getPackageVersion(server.config.root, packageName));
+					} catch (error) {
+						sendError(res, "Failed to get package version", error);
+					}
+					return;
+				}
+				if (req.url === "/environment-info") {
+					try {
+						sendJSON(res, getEnvironmentInfo(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get environment info", error);
+					}
+					return;
+				}
+				if (req.url === "/issue" && req.method === "POST") {
+					try {
+						const chunks = [];
+						req.on("data", (chunk) => chunks.push(chunk));
+						req.on("end", async () => {
+							try {
+								const body = JSON.parse(Buffer.concat(chunks).toString());
+								sendJSON(res, await submitIssue(server.config.root, body));
+							} catch (error) {
+								sendError(res, "Failed to submit issue", error);
+							}
+						});
+					} catch (error) {
+						sendError(res, "Failed to submit issue", error);
+					}
+					return;
+				}
+				next();
+			});
+		}
+	};
+}
+/**
+* 发送 JSON 响应（不做美化，减小体积）
+*/
+function sendJSON(res, data) {
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify(data));
+}
+/**
+* 发送 500 错误响应
+*/
+function sendError(res, defaultMessage, error) {
+	res.statusCode = 500;
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify({
+		error: defaultMessage,
+		message: error instanceof Error ? error.message : String(error)
+	}));
+}
+
+//#endregion
+export { pubinfoDevtools };