/** * 预览用的迷你宿主。 * * ## 它做什么 * * 把真实宿主在启动时做的事,在浏览器里搭一份**最小可跑**的版本: * 扩展点注册表(菜单/路由/命令/事件/视图模型)、`ctx` 工厂、以及 * 「注册即自动回收」的禁用语义。好让插件在**不构建、不发布、不开宿主** * 的情况下被看见。 * * ## 它明确不做什么(这段比上面那段重要) * * | 缺口 | 后果 / 怎么办 | * | ---- | ------------- | * | 没有路由框架 | 预览直接把注册的页面组件渲染出来。真实宿主里的路径规则、权限、嵌套路由验不到 | * | `funjiaui` 是桩 | 用 `UmTable` 等真实行为要在宿主里看;预览只保证不崩、有占位 | * | 后端是**内置 mock** | `ctx.http` 真的发请求、真的拿得到数据,但数据是 `preview/mock-api.ts` 里的固定几行,进程重启即重置。接真后端用 `PREVIEW_API_TARGET` 代理过去 | * | 没有路由守卫 | 预览有登录/登出,但「未登录一律拦到登录页」是**宿主**的行为,预览不拦 —— 插件页面在未登录时照样打得开,只是接口会回 401 | * | 不做权限判定 | `ctx.getUser()` 拿得到真实角色,但拦不拦由插件自己写。宿主里也一样,只是宿主多了守卫那一层 | * | 不校验完整性 | 产物模式加载的是本地 `dist/`,不做 checksum 比对 | * * 所以请把预览当作**开发时的镜子**,而不是验收环境: * * > 预览里看不到的东西 ≠ 宿主里也没问题。 * > 交付前那一次 `deploy` + 宿主安装,仍然要走。 * * ## 与真实宿主的实现差异(有意为之) * * 真实宿主的扩展点注册表在 `src/core/plugin/extensionRegistry.ts`,预览这份是 * **独立实现**,没有 import 宿主的任何模块 —— 插件工程看不到宿主源码, * 也不该为了预览去依赖它。代价是两边可能慢慢漂移,收益是插件工程零宿主依赖。 * 判断「漂移了没有」的方式很直接:在宿主里装一次,对比行为。 */ import { markRaw, reactive } from "vue"; import type { PluginCtx, PluginModule } from "../src/sdk"; import { HOST_NAME, HOST_VERSION, hostInfo, pendingRegistrations } from "./contract"; import { AUTH_EVENTS, TOKEN_KEY, UNAUTHORIZED_CODE, USER_KEY, type ApiResult, type AuthUser, type DemoAccount, } from "./api-contract"; /** 宿主注入给插件的元数据。真实宿主里来自仓库索引条目 */ export interface PreviewManifest { id: string; name: string; version: string; kind: string; activation?: string; repository?: string; checksum?: string; } export type LogLevel = "debug" | "info" | "warn" | "error" | "ui"; export interface LogItem { seq: number; level: LogLevel; text: string; time: string; } export interface EventItem { seq: number; scope: "local" | "global"; name: string; payload: string; time: string; } export interface CommandResult { ok: boolean; value?: any; error?: string; ms: number; } const MAX_LOG = 400; /** 屏蔽 Vue 把组件对象变成响应式代理 —— 那会让 Vue 自己发出警告,且渲染行为改变 */ function raw(value: T): T { return (typeof value === "object" && value !== null) ? markRaw(value as any) : value; } export function createPreviewHost(manifest: PreviewManifest) { /* ------------------------------------------------------------ 状态 */ const state = reactive({ menus: [] as any[], routes: [] as any[], widgets: [] as any[], toolbarActions: [] as any[], settingsSections: [] as any[], viewModels: {} as Record, commands: {} as Record, logs: [] as LogItem[], events: [] as EventItem[], /** 插件私有存储的镜像(真身在 localStorage,这里只为了界面能显示) */ storage: {} as Record, /** 已注册的事件通道(供界面手动触发) */ channels: [] as { scope: "local" | "global"; name: string }[], /** idle(未启用)/ active(已启用)/ error(activate 抛错) */ phase: "idle" as "idle" | "active" | "error", error: "", activatedAt: "", /** 上一次 activate 里登记了多少个自动清理项 */ disposerCount: 0, /** 预览环境的登录态:`null` = 未登录,与宿主 `ctx.getUser()` 同口径 */ user: null as AuthUser | null, /** 裸令牌(**不带** `Bearer ` 前缀 —— 前缀由请求层统一补,见 authHeaderOf) */ token: "", /** 上一次鉴权失败的原因。401 时由 send 写入,界面据此给提示 */ authNotice: "", /** * 401 计数器。**不能只用 `authNotice` 文本**: * 界面用 `watch` 监听它来弹登录框,而 watch 只在**值变化**时触发 —— * 连续两次同样的 401(比如未登录时点了两次「拉列表」)第二次就不会弹框了, * 表现为「第一次有反应、之后点着没动静」。计数器每次必增,绕开这个坑。 */ authNoticeSeq: 0, /** 登录/登出进行中,界面用来禁用按钮 */ authBusy: false, }); let seq = 0; const now = () => new Date().toLocaleTimeString("zh-CN", { hour12: false }); function pushLog(level: LogLevel, text: string) { state.logs.push({ seq: ++seq, level, text, time: now() }); if (state.logs.length > MAX_LOG) state.logs.splice(0, state.logs.length - MAX_LOG); } function pushEvent(scope: "local" | "global", name: string, args: any[]) { // 事件流水单独一个列表:它和日志混在一起会看不清「谁发了什么、谁收到了」 state.events.push({ seq: ++seq, scope, name, payload: args.length ? safeStringify(args.length === 1 ? args[0] : args) : "", time: now(), }); if (state.events.length > MAX_LOG) state.events.splice(0, state.events.length - MAX_LOG); } function safeStringify(value: any): string { try { const s = typeof value === "string" ? value : JSON.stringify(value); return s === undefined ? String(value) : s; } catch { return String(value); } } /* -------------------------------------------------- 插件私有存储 */ // 用 localStorage 而不是内存 Map:刷新页面后插件还能看到自己上次存的东西, // 这样「install 只跑一次」「bootCount 递增」这类行为才验得出来 const prefix = `funjia-preview:${manifest.id}:`; function storageKeys(): string[] { const keys: string[] = []; for (let i = 0; i < localStorage.length; i++) { const k = localStorage.key(i); if (k && k.startsWith(prefix)) keys.push(k.slice(prefix.length)); } return keys; } function syncStorageMirror() { const dump: Record = {}; for (const k of storageKeys()) dump[k] = localStorage.getItem(prefix + k); state.storage = dump; } const storage = { get(key: string, fallback?: T): T { const raw = localStorage.getItem(prefix + key); if (raw === null) return fallback as T; try { return JSON.parse(raw) as T; } catch { return raw as unknown as T; } }, set(key: string, value: any) { localStorage.setItem(prefix + key, JSON.stringify(value)); syncStorageMirror(); }, remove(key: string) { localStorage.removeItem(prefix + key); syncStorageMirror(); }, }; function clearStorage() { for (const k of storageKeys()) localStorage.removeItem(prefix + k); syncStorageMirror(); } /* -------------------------------------------------------- 事件总线 */ /** * 局部 / 全局两个通道分成两个 Map,而不是「一个带前缀的复合 key」。 * * 复合 key 看着省事,但读回来要靠 `split` 的位置约定 —— 写错不会报错, * 只会让「已注册通道」列表显示成别的字段(第一版就踩了这个:通道名 * 解析成了插件 id,于是界面上出现一个 `:acme.hello` 这样的鬼东西)。 * 分成两个 Map,结构上就不可能串。 */ const localListeners = new Map void>>(); const globalListeners = new Map void>>(); const bucketOf = (scope: "local" | "global") => scope === "global" ? globalListeners : localListeners; function syncChannels() { const out: { scope: "local" | "global"; name: string }[] = []; for (const name of localListeners.keys()) out.push({ scope: "local", name }); for (const name of globalListeners.keys()) out.push({ scope: "global", name }); state.channels = out; } function on(scope: "local" | "global", name: string, handler: (...args: any[]) => void) { const bucket = bucketOf(scope); if (!bucket.has(name)) bucket.set(name, new Set()); bucket.get(name)!.add(handler); syncChannels(); return () => { bucket.get(name)?.delete(handler); syncChannels(); }; } function emit(scope: "local" | "global", name: string, args: any[]) { pushEvent(scope, name, args); const set = bucketOf(scope).get(name); if (!set || set.size === 0) { pushLog("debug", `emit ${scope === "global" ? "全局" : "局部"}事件 ${name} —— 当前没有监听者`); return; } for (const handler of [...set]) { try { handler(...args); } catch (e) { // 一个监听器抛错不该带崩整条总线 —— 真实宿主也是逐个隔离的 pushLog("error", `事件监听器抛错(${name}):${(e as Error)?.message ?? e}`); } } } /* -------------------------------------------------- 回收与注册表 */ const disposers: Array<() => void> = []; function track(dispose: () => void) { disposers.push(dispose); return dispose; } function runDisposers() { // 倒序执行:后注册的先撤,与「栈」的直觉一致 for (const fn of disposers.splice(0).reverse()) { try { fn(); } catch (e) { pushLog("warn", `自动清理项抛错:${(e as Error)?.message ?? e}`); } } } /** 清空注册表。真实宿主在禁用时做的正是这件事 —— 所以插件不需要写反注册 */ function clearRegistry() { state.menus = []; state.routes = []; state.widgets = []; state.toolbarActions = []; state.settingsSections = []; state.viewModels = {}; state.commands = {}; localListeners.clear(); globalListeners.clear(); state.channels = []; } /** 从数组里摘掉一个元素,并返回「摘掉」这个动作 —— 这就是注册返回的 disposer */ function register(list: T[], item: T): () => void { list.push(raw(item)); return () => { const i = list.indexOf(item); if (i >= 0) list.splice(i, 1); }; } /* ------------------------------------------------------------ 登录态 */ /** * 令牌与用户信息的读写集中在这几个小函数里,别处**不再直接碰 localStorage**。 * * 宿主里对应的是 `src/core/auth/token.ts`。之所以要收敛:老版本把令牌的存取 * 散在三处(会话层读写、请求层 `getItem`、清空时各自 `removeItem`), * 任何一处改了 key 都会出现「登录明明成功、请求却不带令牌」—— * 只在运行时暴露,且一定会被误判成后端问题。 */ function readStoredToken(): string { try { return localStorage.getItem(TOKEN_KEY) || ""; } catch { // 隐私模式读不到就当匿名,别让一个存储异常把启动带崩 return ""; } } function readStoredUser(): AuthUser | null { try { const raw = localStorage.getItem(USER_KEY); return raw ? (JSON.parse(raw) as AuthUser) : null; } catch { return null; } } function saveAuth(token: string, user: AuthUser | null) { state.token = token; state.user = user ? raw(user) : null; try { localStorage.setItem(TOKEN_KEY, token); if (user) localStorage.setItem(USER_KEY, JSON.stringify(user)); else localStorage.removeItem(USER_KEY); } catch { // 存不下(隐私模式 / 配额满)不影响当前会话,只是刷新后要重新登录 } } function clearAuth() { state.token = ""; state.user = null; try { localStorage.removeItem(TOKEN_KEY); localStorage.removeItem(USER_KEY); } catch { /* 同上:清不掉也不该抛 */ } } /** * `Authorization` 头的值。未登录返回**空串** → 请求头里干脆不带这个字段。 * * 前缀只在这里补一次。localStorage 里存的是**裸令牌** —— 想验证这条约定 * 有没有被破坏,看 `mock-api.ts`:它按真后端的严格程度校验那个头, * 少一个 `Bearer ` 就当未授权。 */ const authHeaderOf = () => (state.token ? `Bearer ${state.token}` : ""); /** * 广播登录态。**事件名与宿主完全一致**(`src/core/session.ts` 的 `globalBus`), * 所以插件里那句 `ctx.event.onGlobal("user:logout", ...)` 在预览里同样接到东西。 */ function broadcastAuth(name: string, payload?: any) { emit("global", name, payload === undefined ? [] : [payload]); } /** * 未授权的统一处理:清会话(如果有)+ 提示 + 广播。 * * **清会话这一步必须幂等**:一个页面并发五个请求时,401 会连着来五次。 * 判据是「当前会话是否已经空了」—— 与宿主 session 侧同构。 * * ## 与宿主**有意不同**的一处 * * 宿主靠**路由守卫**保证「未登录根本进不来任何页面」,所以它只在 * 「原本有会话、现在失效了」时才提示。预览没有守卫:一个未登录的插件页面 * 照样打得开,这时如果 401 一声不吭,作者看到的是「点了按钮没反应」, * 而真正的原因在浏览器网络面板里(一个 401)—— 这属于最难查的一类问题。 * * 所以预览里**一律**把登录框弹出来,并在文案上区分两种情况。 */ function handleUnauthorized(reason: string) { const hadSession = !!(state.token || state.user); if (hadSession) { clearAuth(); broadcastAuth(AUTH_EVENTS.logout); } state.authNotice = hadSession ? reason || "登录状态已失效,请重新登录" : `接口需要登录(${reason || "未登录"})—— 登录后重试`; state.authNoticeSeq += 1; pushLog( "warn", hadSession ? `接口返回 401(${state.authNotice})→ 已清除预览环境的登录态` : `接口返回 401:${state.authNotice}` ); } /** * 启动恢复:刷新页面后把登录态接回来。 * * ⚠️ **必须在插件装载之前完成** —— 插件 `activate` 里的 `ctx.getUser()` * 会据此判断「有没有人登录」。宿主里这个顺序更严格(还要早于路由守卫), * 预览里没有路由,只剩这一条约束。见 `App.vue` 的 `onMounted`。 * * 三个取舍都与宿主一致: * - **没有令牌就立即返回,不发请求** —— 未登录的首屏不该为一次必然 401 的往返付延迟; * - 有令牌却没有用户信息 → 本地数据不一致,**丢掉重来**; * - **后端不可达时保留登录态** —— 网络抖动不该把用户清下线。 */ async function restoreSession() { const token = readStoredToken(); if (!token) { clearAuth(); return; } const cached = readStoredUser(); if (!cached) { clearAuth(); pushLog("warn", "启动恢复:本地有令牌但没有用户信息(数据不一致),已清除"); return; } state.token = token; state.user = raw(cached); let result: ApiResult; try { result = await send("GET", "/api/auth/me", undefined); } catch (e) { // 网络层失败:保留本地登录态(与宿主 bootstrapSession 的 catch 分支同口径) pushLog("warn", `启动恢复:后端不可达,沿用本地登录态(${(e as Error)?.message ?? e})`); return; } if (result.code === UNAUTHORIZED_CODE) { // 401 已经由 send → handleUnauthorized 处理(清态 + 提示 + 广播),这里不重复 return; } if (result.code !== 0 || !result.data) { clearAuth(); pushLog("warn", `启动恢复失败(${result.msg}),已清除本地登录态`); return; } // 用服务端的权威信息覆盖本地缓存:名字、角色可能已被改过 saveAuth(token, result.data); pushLog("info", `启动恢复:已登录为 ${state.user?.name}(${state.user?.role})`); } /** * 登录。业务失败(账号密码不对)**不抛错**,返回 `{ ok: false, message }` —— * 与宿主 `session.login()` 的返回形状一致,登录页两边都能直接用。 */ async function login(account: string, password: string): Promise<{ ok: boolean; message?: string }> { if (state.authBusy) return { ok: false, message: "正在处理上一个请求,请稍候" }; state.authBusy = true; state.authNotice = ""; const hadUser = !!state.user; try { const result = await send("POST", "/api/auth/login", { account, password }); if (result.code !== 0 || !result.data?.token) { // 刻意不区分「账号不存在」与「密码错误」:与后端、宿主同口径,避免账号枚举 return { ok: false, message: result.msg || "登录失败" }; } const user = result.data.user as AuthUser; saveAuth(result.data.token, user); pushLog("info", `已登录:${user?.name ?? account}(${user?.role ?? ""})`); // 只在「从无到有」时广播:恢复会话会用服务端信息覆盖一次,那不算新登录 if (!hadUser && user) broadcastAuth(AUTH_EVENTS.login, user); return { ok: true }; } catch (e) { return { ok: false, message: `网络异常:${(e as Error)?.message ?? e}` }; } finally { state.authBusy = false; } } /** * 登出。 * * 通知后端是**尽力而为**:令牌已过期时这个请求本身就是必然 401, * 但本地**必须**清干净 —— 否则用户会卡在「点了退出还是登录态」里, * 只能手动清 localStorage。这里用 try/catch 而不是让 401 抛出来打断清理。 */ async function logout() { if (state.authBusy) return; state.authBusy = true; try { await send("POST", "/api/auth/logout", {}); } catch { // 后端不通不影响登出:本地清掉就等于登出了 } finally { clearAuth(); state.authNotice = ""; state.authBusy = false; // 广播放最后:监听者拿到事件时,登录态已经是干净的了 broadcastAuth(AUTH_EVENTS.logout); pushLog("info", "已退出登录:本地令牌与用户信息已清空"); } } /** * 演示账号清单(登录页直接列出来,省掉「翻文档找账号」这一步)。 * * 走接口而不是写死在界面里是有意的:**真后端不会实现这个接口**, * 那时这里返回空数组,登录页自动把整块收起来 —— * 界面不需要知道「当前连的是 mock 还是真后端」。 * * 用 `rawRequest` 而不是 `send`:这是一次探针调用, * 失败是正常情况,不该在日志里刷一条 404 警告,也不该触发 401 处理。 */ async function demoAccounts(): Promise { try { const result = await rawRequest("GET", "/api/auth/demo-accounts", undefined); return result.code === 0 && Array.isArray(result.data) ? result.data : []; } catch { // 真后端没有这个接口 → 静默留空 return []; } } /* --------------------------------------------------------- ctx 请求层 */ /** * 请求层错误(**基础设施**故障,不是业务码)。 * * 与宿主的 `HttpError` 同形:业务码非 0 **不抛错**(老系统的写法是 * `const {code,msg} = await api.add()`,抛错会让那套写法全部失效), * 只有连不上、网关 5xx、响应不是 JSON 这类才抛。 */ class PreviewHttpError extends Error { constructor(public readonly status: number, message: string, public readonly url: string) { super(message); this.name = "PreviewHttpError"; } } /** 把参数对象拼成查询串,跳过空值(与宿主 `toQuery` 同规则) */ function toQuery(params?: Record): string { if (!params) return ""; const parts: string[] = []; for (const [key, value] of Object.entries(params)) { if (value === undefined || value === null || value === "") continue; parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`); } return parts.length ? `?${parts.join("&")}` : ""; } /** * 发一个请求(不含 401 处理,见 `send`)。 * * ## 与宿主 `src/core/http/index.ts` 的 `realRequest` 对齐 * * | 情况 | 这里 | 宿主 | * | ---- | ---- | ---- | * | HTTP 401 | 归一成 `{code: 401}`,**不抛** | 同 | * | 其它非 2xx | **抛** `PreviewHttpError` | 抛 `HttpError` | * | 响应是包络 | 原样返回 | 同 | * | 响应是裸数据 | 补成 `{code: 0, data}` | 同 | * * 老版本的预览桩子在这三处都不一样:HTTP 状态码直接当业务码、 * 把整个包络塞进 `data`(于是插件拿到的 `res.data.rows` 永远是 `undefined`)、 * 出错一律返回 `code: -1` 从不抛。结果是**预览里过得去的代码,到宿主里全是坑** —— * 这里刻意改成同构。 */ async function rawRequest(method: string, url: string, payload: any): Promise> { const verb = (method || "GET").toUpperCase(); const finalUrl = verb === "GET" || verb === "DELETE" ? `${url}${toQuery(payload)}` : url; const headers: Record = { "Content-Type": "application/json;charset=utf-8", "Cache-Control": "no-cache", }; // 未登录时**不带** Authorization 字段,而不是带一个空值 —— // 某些网关对空的 `Authorization: ` 会直接拒请求(而不是当匿名) const authorization = authHeaderOf(); if (authorization) headers.Authorization = authorization; const res = await fetch(finalUrl, { method: verb, headers, body: verb === "GET" || verb === "DELETE" ? undefined : JSON.stringify(payload ?? {}), }); if (res.status === 401) { return { code: UNAUTHORIZED_CODE, msg: "未登录或登录已过期", data: null as unknown as T }; } if (!res.ok) { throw new PreviewHttpError(res.status, `请求失败 ${res.status}:${url}`, url); } const text = await res.text(); let parsed: any = null; try { parsed = text ? JSON.parse(text) : null; } catch { throw new PreviewHttpError(res.status, `响应不是合法 JSON:${url}`, url); } // 真后端可能只返回裸数据(没有 code 包装),这里补齐成统一形状 if (parsed && typeof parsed === "object" && "code" in parsed) return parsed as ApiResult; return { code: 0, msg: "ok", data: parsed as T }; } /** * `ctx.http` 的入口:请求 + 统一的 401 处理。 * * 401 是**唯一有副作用**的一种返回:清会话、提示、广播登出。 * **插件不需要为它写任何代码** —— 拿到 401 直接 return 即可,与宿主一致。 */ async function send(method: string, url: string, payload?: any): Promise> { const label = `http.${method.toLowerCase()}(${url})`; try { const result = await rawRequest(method, url, payload); if (result.code === UNAUTHORIZED_CODE) { pushLog("warn", `${label} → 401`); handleUnauthorized(result.msg); } else { pushLog("info", `${label} → code ${result.code}${result.code === 0 ? "(ok)" : `(${result.msg})`}`); } return result; } catch (e) { const err = e as PreviewHttpError; pushLog("error", `${label} 失败:${err?.message ?? err}`); throw e; } } /** `ctx.http` 的四个方法。`payload` 对 GET/DELETE 是查询参数,对其它是请求体 */ const httpCall = (method: string, url: string, payload?: any) => send(method, url, payload); /* ---------------------------------------------------------------- ctx */ function createCtx(): PluginCtx { const ctx: PluginCtx = { hostVersion: HOST_VERSION, plugin: { id: manifest.id, name: manifest.name, version: manifest.version, kind: manifest.kind, repository: manifest.repository, checksum: manifest.checksum, }, logger: { debug: (...a: any[]) => pushLog("debug", a.map(safeStringify).join(" ")), info: (...a: any[]) => pushLog("info", a.map(safeStringify).join(" ")), warn: (...a: any[]) => pushLog("warn", a.map(safeStringify).join(" ")), error: (...a: any[]) => pushLog("error", a.map(safeStringify).join(" ")), }, storage, http: { // 与宿主 `PluginHttp` 同形:多一个 request(),给「method 是算出来的」场景用 request: (options: any) => { const method = String(options?.method || "GET").toUpperCase(); const payload = method === "GET" || method === "DELETE" ? options?.params : options?.data; return httpCall(method, options?.url, payload); }, get: (url, params) => httpCall("GET", url, params), post: (url, data) => httpCall("POST", url, data), put: (url, data) => httpCall("PUT", url, data), del: (url, params) => httpCall("DELETE", url, params), }, ui: { success: (m: string) => pushLog("ui", `success: ${m}`), error: (m: string) => pushLog("ui", `error: ${m}`), warning: (m: string) => pushLog("ui", `warning: ${m}`), info: (m: string) => pushLog("ui", `info: ${m}`), // 用浏览器原生弹窗:够真(会阻塞),也不必为此引入一套消息组件 confirm: async (m: string, title = "确认") => window.confirm(`${title}\n\n${m}`), alert: async (m: string, title = "提示") => { window.alert(`${title}\n\n${m}`); }, }, /** * 当前登录用户。**与宿主同口径**:直接返回会话里的那个用户对象, * 未登录返回 `null`(而不是一个假的「预览用户」)—— * 插件据此做角色降级,预览里才能真的验到「普通用户看不到某个按钮」。 * * 返回展开后的副本而不是原对象:调用方顺手改一下不该影响会话。 */ getUser: () => (state.user ? { ...state.user } : null), addMenu: (menu) => track(register(state.menus, menu)), addRoute: (route) => track(register(state.routes, route)), addWidget: (w) => track(register(state.widgets, w)), addToolbarAction: (a) => track(register(state.toolbarActions, a)), addSettingsSection: (s) => track(register(state.settingsSections, s)), addViewModel: (model) => { state.viewModels[model.name] = raw(model.target); return track(() => { delete state.viewModels[model.name]; }); }, getViewModel: (name) => state.viewModels[name], addCommand: (command) => { state.commands[command.name] = raw(command); return track(() => { delete state.commands[command.name]; }); }, getCommand: (name) => state.commands[name], event: { on: (name, handler) => track(on("local", name, handler)), emit: (name, ...args) => emit("local", name, args), onGlobal: (name, handler) => track(on("global", name, handler)), emitGlobal: (name, ...args) => emit("global", name, args), }, onDispose: (fn) => track(fn), }; return ctx; } /* -------------------------------------------------------- 生命周期 */ /** 认领自注册队列里属于本插件的模块(真实宿主按 manifest.id 认领,这里同样) */ function claim(): PluginModule | null { const i = pendingRegistrations.findIndex((r) => r?.manifest?.id === manifest.id); if (i < 0) return null; return pendingRegistrations.splice(i, 1)[0].module as PluginModule; } /** 探测自注册队列里都有谁 —— 认领失败时用来给出可执行的提示 */ function pendingIds(): string[] { return pendingRegistrations.map((r) => String(r?.manifest?.id ?? "(无 id)")); } const installedFlag = `funjia-preview:meta:${manifest.id}:installed`; let currentCtx: PluginCtx | null = null; async function activate(module: PluginModule) { // 重新启用前先清干净:真实宿主在禁用时已经回收过,这里保证同一语义 runDisposers(); clearRegistry(); const ctx = createCtx(); currentCtx = ctx; state.error = ""; try { // install 一辈子只跑一次 —— 用持久化标记模拟「首次装载」,与真实宿主同口径 if (localStorage.getItem(installedFlag) !== "1") { await module.install?.(ctx); localStorage.setItem(installedFlag, "1"); pushLog("info", "install 已执行(首次装载,标记已持久化:刷新或重新启用都不会再跑)"); } await module.activate?.(ctx); state.phase = "active"; state.activatedAt = now(); state.disposerCount = disposers.length; pushLog( "info", `activate 完成:注册 ${state.menus.length} 菜单 / ${state.routes.length} 路由 / ` + `${Object.keys(state.commands).length} 命令 / ${state.channels.length} 事件通道,` + `${disposers.length} 个待回收项` ); } catch (e) { state.phase = "error"; state.error = String((e as Error)?.message ?? e); pushLog("error", `activate 抛错:${state.error}`); throw e; } } async function deactivate(module?: PluginModule | null) { if (module) { try { await module.deactivate?.(currentCtx as PluginCtx); } catch (e) { pushLog("error", `deactivate 抛错:${(e as Error)?.message ?? e}`); } } runDisposers(); clearRegistry(); state.disposerCount = 0; state.activatedAt = ""; state.phase = "idle"; pushLog("info", "已停用:菜单/路由/命令/事件监听全部回收(真实宿主在同一时机做同样的事)"); } async function uninstall(module?: PluginModule | null) { await deactivate(module); if (module) { try { await module.uninstall?.(currentCtx as PluginCtx); } catch (e) { pushLog("error", `uninstall 抛错:${(e as Error)?.message ?? e}`); } } clearStorage(); localStorage.removeItem(installedFlag); pushLog("info", "已卸载:插件私有存储与 install 标记已清空(下次启用会重新走 install)"); } /* ------------------------------------------------ 供预览界面调用 */ async function callCommand(name: string, args: any[]): Promise { const started = performance.now(); const command = state.commands[name]; if (!command) { const ms = performance.now() - started; pushLog("warn", `调用命令 ${name} 失败:未注册`); return { ok: false, error: `命令 ${name} 未注册`, ms }; } try { const value = await command.handler(...args); const ms = performance.now() - started; pushLog("info", `调用命令 ${name} → ${safeStringify(value)}(${ms.toFixed(1)}ms)`); return { ok: true, value, ms }; } catch (e) { const ms = performance.now() - started; const error = String((e as Error)?.message ?? e); pushLog("error", `调用命令 ${name} 抛错:${error}`); return { ok: false, error, ms }; } } function invokeLocal(name: string, args: any[]) { emit("local", name, args); } function invokeGlobal(name: string, args: any[]) { emit("global", name, args); } /* ---------------------------------------------- 补全 window.FunjiaHost */ // hostInfo 是 contract.ts 里那个**同一个对象引用**。这里只补字段, // 不换对象 —— 插件若在模块求值时就把 window.FunjiaHost 存起来了,也能看到这些实现 Object.assign(hostInfo, { name: HOST_NAME, version: HOST_VERSION, http: { get: (url: string, params?: any) => httpCall("GET", url, params), post: (url: string, data?: any) => httpCall("POST", url, data), put: (url: string, data?: any) => httpCall("PUT", url, data), del: (url: string, params?: any) => httpCall("DELETE", url, params), }, getViewModel: (name: string) => state.viewModels[name], // 与宿主 `FunjiaHost.getUser/isLoggedIn` 同名同义。给**没有 ctx** 的 // 裸脚本插件用(例如纯配置类插件),它们在预览里也要能判断登录态 getUser: () => (state.user ? { ...state.user } : null), isLoggedIn: () => !!state.user, stats: () => ({ menus: state.menus.length, routes: state.routes.length, widgets: state.widgets.length, toolbarActions: state.toolbarActions.length, settingsSections: state.settingsSections.length, viewModels: Object.keys(state.viewModels).length, commands: Object.keys(state.commands).length, }), }); return { manifest, state, pushLog, claim, pendingIds, activate, deactivate, uninstall, callCommand, invokeLocal, invokeGlobal, /* 登录态:预览界面用它渲染顶栏的登录区,插件页面靠 `ctx.getUser()` 读 */ login, logout, restoreSession, demoAccounts, clearLogs: () => { state.logs = []; state.events = []; }, clearStorage, syncStorageMirror, }; } export type PreviewHost = ReturnType;