@e-xi/xion 0.0.6

package/dist/chunk-files/chunk-DRMV3M5V.js

@@ -0,0 +1,1970 @@
+import {
+  WindowUtil
+} from "./chunk-YZOJOLFL.js";
+import {
+  defineMainWindowConfig,
+  defineSettingWindowConfig
+} from "./chunk-F7YTK2MY.js";
+import {
+  FileAssociationUtil
+} from "./chunk-VGDNICVG.js";
+import {
+  MainWindowIdentity
+} from "./chunk-KFV4GXVE.js";
+import {
+  ContextMenuChannels,
+  WindowChannels
+} from "./chunk-BFD2LHLK.js";
+import {
+  SettingWindowIdentity
+} from "./chunk-PVWRRUOK.js";
+import {
+  ProtocolUtil
+} from "./chunk-KFK47PDH.js";
+import {
+  AppMode
+} from "./chunk-GN2FNR3Z.js";
+
+// src/main/window/window-lifecycle-abstract.ts
+import { shell } from "electron";
+var WindowLifecycleAbstract = class {
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 创建窗口前
+   * @param {XoWindow.Type}                            type    窗口类型
+   * @param {Electron.BrowserWindowConstructorOptions} options 窗口配置
+   * @returns {Promise<void>}
+   */
+  async beforeCreate(type, options) {
+  }
+  /**
+   * 创建窗口后
+   * <p>项目中可以在此方法中处理窗口事件，如：</p>
+   * <p>record.window.on('always-on-top-changed', () => {})</p>
+   * <p>record.window.webContents.on('context-menu', () => {})</p>
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async afterCreated(record) {
+  }
+  /**
+   * 加载窗口渲染进程
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async loadIndex(record) {
+    if (AppMode.isDev()) {
+      await WindowUtil.loadUrl(this.xoApp, record);
+      return;
+    }
+    const rendererProtocolUrl = this.xoApp.getRendererProtocolManager().entryUrl(record.url);
+    if (rendererProtocolUrl) {
+      this.xoApp.getRendererProtocolManager().initializeSession(record.window.webContents.session);
+      await WindowUtil.loadProtocol(this.xoApp, record, rendererProtocolUrl);
+      return;
+    }
+    await WindowUtil.loadFile(this.xoApp, record);
+  }
+  /**
+   * 窗口准备显示
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onceReadyToShow(record) {
+  }
+  /**
+   * 页面加载完成
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onShow(record) {
+    this.isMainWindow(record) && this.xoApp.getTrayManager().setFocus();
+  }
+  /**
+   * 窗口隐藏
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onHide(record) {
+    this.isMainWindow(record) && this.xoApp.getTrayManager().setBlur();
+  }
+  /**
+   * 窗口获得焦点
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onFocus(event, record) {
+  }
+  /**
+   * 窗口失去焦点
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onBlur(event, record) {
+  }
+  /**
+   * 窗口尺寸变化
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onResize(record) {
+  }
+  /**
+   * 窗口尺寸变化完成
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onResized(record) {
+    this.xoApp.getAppStore().setWindowRectangle(record.type.name, this.getWindowRectangle(record));
+  }
+  /**
+   * 窗口位置变化
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onMove(record) {
+  }
+  /**
+   * 窗口位置移动完成
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onMoved(record) {
+    this.xoApp.getAppStore().setWindowRectangle(record.type.name, this.getWindowRectangle(record));
+  }
+  /**
+   * 窗口最大化
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onMaximize(record) {
+  }
+  /**
+   * 窗口退出最大化
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onUnmaximize(record) {
+  }
+  /**
+   * 窗口最小化
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onMinimize(record) {
+    this.isMainWindow(record) && this.xoApp.getTrayManager().setBlur();
+  }
+  /**
+   * 窗口恢复
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onRestore(record) {
+    this.isMainWindow(record) && this.xoApp.getTrayManager().setFocus();
+  }
+  /**
+   * 进入全屏
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onEnterFullScreen(record) {
+  }
+  /**
+   * 退出全屏
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onLeaveFullScreen(record) {
+  }
+  /**
+   * 窗口置顶状态变化
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onAlwaysOnTopChanged(record) {
+  }
+  /**
+   * 窗口关闭前
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onClose(event, record) {
+    if (this.xoApp.isQuitting()) {
+      return;
+    }
+    if (this.isMainWindow(record)) {
+      if (this.xoApp.getAppStore().getWindowCloseBehavior() === "quit") {
+        this.xoApp.quit();
+        return;
+      }
+      event.preventDefault();
+      record.window.hide();
+      return;
+    }
+  }
+  /**
+   * 窗口已关闭
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onClosed(record) {
+    this.xoApp.windowLog.info(`\u7A97\u53E3\u5DF2\u5173\u95ED`, WindowUtil.recordToUID(record));
+  }
+  /**
+   * 窗口无响应
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onUnresponsive(record) {
+    this.xoApp.windowLog.warn(`\u7A97\u53E3\u65E0\u54CD\u5E94`, WindowUtil.recordToUID(record));
+  }
+  /**
+   * 窗口恢复响应
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onResponsive(record) {
+    this.xoApp.windowLog.info("\u7A97\u53E3\u6062\u590D\u54CD\u5E94", WindowUtil.recordToUID(record));
+  }
+  /**
+   * 页面加载完成
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDidFinishLoad(record) {
+    if (this.isMainWindow(record) && this.xoApp.isWindowLaunchMode() && !this.isExternalLaunchMode()) {
+      this.xoApp.getWindowManager().showByWindow(record.window);
+    }
+  }
+  /**
+   * 页面开始加载
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDidStartLoading(record) {
+  }
+  /**
+   * 页面停止加载
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDidStopLoading(record) {
+  }
+  /**
+   * 页面 DOM 准备完成
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDomReady(record) {
+  }
+  /**
+   * 页面标题更新
+   * @param {Electron.Event}  event       事件对象
+   * @param {XoWindow.Record} record      窗口实例
+   * @param {string}          title       页面标题
+   * @param {boolean}         explicitSet 是否显式设置标题
+   * @returns {Promise<void>}
+   */
+  async onWebContentsPageTitleUpdated(event, record, title, explicitSet) {
+  }
+  /**
+   * 页面图标更新
+   * @param {Electron.Event}  event    事件对象
+   * @param {XoWindow.Record} record   窗口实例
+   * @param {string[]}        favicons 图标地址
+   * @returns {Promise<void>}
+   */
+  async onWebContentsPageFaviconUpdated(event, record, favicons) {
+  }
+  /**
+   * webContents 焦点获得
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsFocus(record) {
+  }
+  /**
+   * webContents 焦点失去
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsBlur(record) {
+  }
+  /**
+   * webContents 主题色变化
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @param {string | null}   color  主题色
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDidChangeThemeColor(event, record, color) {
+  }
+  /**
+   * webContents 目标地址变化
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @param {string}          url    目标地址
+   * @returns {Promise<void>}
+   */
+  async onWebContentsUpdateTargetUrl(event, record, url) {
+  }
+  /**
+   * webContents 即将跳转
+   * @param {Electron.Event}  event              事件对象
+   * @param {XoWindow.Record} record             窗口实例
+   * @param {string}          url                跳转地址
+   * @param {boolean}         shouldOpenExternal 是否应使用系统浏览器打开
+   * @returns {Promise<void>}
+   */
+  async onWebContentsWillNavigate(event, record, url, shouldOpenExternal) {
+    if (shouldOpenExternal) {
+      event.preventDefault();
+      void shell.openExternal(url);
+    }
+  }
+  /**
+   * webContents 上下文菜单
+   * @param {Electron.Event}             event  事件对象
+   * @param {XoWindow.Record}            record 窗口实例
+   * @param {Electron.ContextMenuParams} params 上下文菜单参数
+   * @returns {Promise<void>}
+   */
+  async onWebContentsContextMenu(event, record, params) {
+    if (this.xoApp.getAppConfig()?.useContextMenuInRenderer) {
+      const contextMenu = this.xoApp.getMenuManager().resolveContextMenu(params, record.window);
+      record.window.webContents.send(ContextMenuChannels.onRequested, contextMenu);
+      return;
+    }
+    this.xoApp.getMenuManager().popupContextMenu(params, record.window);
+  }
+  /**
+   * webContents 按键前置事件
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @param {Electron.Input}  input  输入信息
+   * @returns {Promise<void>}
+   */
+  async onWebContentsBeforeInputEvent(event, record, input) {
+  }
+  /**
+   * webContents 输入事件
+   * @param {Electron.Event}      event      事件对象
+   * @param {XoWindow.Record}     record     窗口实例
+   * @param {Electron.InputEvent} inputEvent 输入事件
+   * @returns {Promise<void>}
+   */
+  async onWebContentsInputEvent(event, record, inputEvent) {
+  }
+  /**
+   * webContents DevTools 打开链接
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @param {string}          url    链接
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDevtoolsOpenUrl(event, record, url) {
+  }
+  /**
+   * webContents DevTools 搜索
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @param {string}          query  关键字
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDevtoolsSearchQuery(event, record, query) {
+  }
+  /**
+   * webContents DevTools 打开
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDevtoolsOpened(record) {
+    const openDevTools = record?.type?.windowConfig?.openDevTools;
+    if (openDevTools) {
+      const productName = this.xoApp.getAppConfig()?.eletronAppConfig?.productName;
+      record.window.webContents.setDevToolsTitle(`${productName ? `${productName} ` : ""}${openDevTools?.title ?? "\u5F00\u53D1\u8005\u5DE5\u5177"}`);
+    }
+  }
+  /**
+   * webContents DevTools 关闭
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDevtoolsClosed(record) {
+  }
+  /**
+   * webContents DevTools 聚焦
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDevtoolsFocused(record) {
+  }
+  /**
+   * webContents 证书错误
+   * @param {Electron.Event}               event       事件对象
+   * @param {XoWindow.Record}              record      窗口实例
+   * @param {string}                       url         请求地址
+   * @param {string}                       error       错误码
+   * @param {Electron.Certificate}         certificate 证书
+   * @param {(isTrusted: boolean) => void} callback    回调函数
+   * @param {boolean}                      isMainFrame 是否主框架
+   * @returns {Promise<void>}
+   */
+  async onWebContentsCertificateError(event, record, url, error, certificate, callback, isMainFrame) {
+  }
+  /**
+   * webContents 选择客户端证书
+   * @param {Electron.Event}                              event           事件对象
+   * @param {XoWindow.Record}                             record          窗口实例
+   * @param {string}                                      url             请求地址
+   * @param {Electron.Certificate[]}                      certificateList 证书列表
+   * @param {(certificate: Electron.Certificate) => void} callback        回调函数
+   * @returns {Promise<void>}
+   */
+  async onWebContentsSelectClientCertificate(event, record, url, certificateList, callback) {
+  }
+  /**
+   * webContents 登录
+   * @param {Electron.Event}                                 event                         事件对象
+   * @param {XoWindow.Record}                                record                        窗口实例
+   * @param {Electron.LoginAuthenticationResponseDetails}    authenticationResponseDetails 认证响应详情
+   * @param {Electron.AuthInfo}                              authInfo                      认证信息
+   * @param {(username?: string, password?: string) => void} callback                      回调函数
+   * @returns {Promise<void>}
+   */
+  async onWebContentsLogin(event, record, authenticationResponseDetails, authInfo, callback) {
+  }
+  /**
+   * webContents 查找结果
+   * @param {Electron.Event}  event  事件对象
+   * @param {XoWindow.Record} record 窗口实例
+   * @param {Electron.Result} result 查找结果
+   * @returns {Promise<void>}
+   */
+  async onWebContentsFoundInPage(event, record, result) {
+  }
+  /**
+   * webContents 媒体开始播放
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsMediaStartedPlaying(record) {
+  }
+  /**
+   * webContents 媒体暂停
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsMediaPaused(record) {
+  }
+  /**
+   * webContents 音频状态变化
+   * @param {Electron.Event<Electron.WebContentsAudioStateChangedEventParams>} event  事件对象
+   * @param {XoWindow.Record}                                                  record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsAudioStateChanged(event, record) {
+  }
+  /**
+   * webContents 控制台消息
+   * @param {Electron.Event<Electron.WebContentsConsoleMessageEventParams>} details 控制台详情
+   * @param {XoWindow.Record}                                               record  窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsConsoleMessage(details, record) {
+  }
+  /**
+   * webContents 预加载错误
+   * @param {Electron.Event}  event       事件对象
+   * @param {XoWindow.Record} record      窗口实例
+   * @param {string}          preloadPath 预加载脚本路径
+   * @param {Error}           error       错误对象
+   * @returns {Promise<void>}
+   */
+  async onWebContentsPreloadError(event, record, preloadPath, error) {
+  }
+  /**
+   * webContents IPC 消息
+   * @param {Electron.IpcMainEvent} event   事件对象
+   * @param {XoWindow.Record}       record  窗口实例
+   * @param {string}                channel 通道
+   * @param {any[]}                 args    参数列表
+   * @returns {Promise<void>}
+   */
+  async onWebContentsIpcMessage(event, record, channel, ...args) {
+  }
+  /**
+   * webContents 同步 IPC 消息
+   * @param {Electron.IpcMainEvent} event   事件对象
+   * @param {XoWindow.Record}       record  窗口实例
+   * @param {string}                channel 通道
+   * @param {any[]}                 args    参数列表
+   * @returns {Promise<void>}
+   */
+  async onWebContentsIpcMessageSync(event, record, channel, ...args) {
+  }
+  /**
+   * webContents 预期尺寸变化
+   * @param {Electron.Event}  event         事件对象
+   * @param {XoWindow.Record} record        窗口实例
+   * @param {Electron.Size}   preferredSize 预期尺寸
+   * @returns {Promise<void>}
+   */
+  async onWebContentsPreferredSizeChanged(event, record, preferredSize) {
+  }
+  /**
+   * webContents frame 创建
+   * @param {Electron.Event}               event   事件对象
+   * @param {XoWindow.Record}              record  窗口实例
+   * @param {Electron.FrameCreatedDetails} details Frame详情
+   * @returns {Promise<void>}
+   */
+  async onWebContentsFrameCreated(event, record, details) {
+  }
+  /**
+   * webContents 即将挂载 webview
+   * @param {Electron.Event}          event          事件对象
+   * @param {XoWindow.Record}         record         窗口实例
+   * @param {Electron.WebPreferences} webPreferences Webview配置
+   * @param {Record<string, string>}  params         Webview参数
+   * @returns {Promise<void>}
+   */
+  async onWebContentsWillAttachWebview(event, record, webPreferences, params) {
+  }
+  /**
+   * webContents 已挂载 webview
+   * @param {Electron.Event}       event       事件对象
+   * @param {XoWindow.Record}      record      窗口实例
+   * @param {Electron.WebContents} webContents Guest WebContents
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDidAttachWebview(event, record, webContents) {
+  }
+  /**
+   * webContents 绘制
+   * @param {Electron.Event<Electron.WebContentsPaintEventParams>} details   绘制详情
+   * @param {XoWindow.Record}                                      record    窗口实例
+   * @param {Electron.Rectangle}                                   dirtyRect 脏矩形
+   * @param {Electron.NativeImage}                                 image     图像
+   * @returns {Promise<void>}
+   */
+  async onWebContentsPaint(details, record, dirtyRect, image) {
+  }
+  /**
+   * webContents DevTools 刷新页面
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDevtoolsReloadPage(record) {
+  }
+  /**
+   * webContents 销毁
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDestroyed(record) {
+  }
+  /**
+   * 页面加载失败
+   * @param {Electron.Event}              event       事件对象
+   * @param {XoWindow.Record}             record      窗口实例
+   * @param {XoWindow.DidFailLoadPayload} failPayload 失败信息
+   * @returns {Promise<void>}
+   */
+  async onWebContentsDidFailLoad(event, record, failPayload) {
+    this.xoApp.windowLog.error("\u7A97\u53E3\u9875\u9762\u52A0\u8F7D\u5931\u8D25", WindowUtil.recordToUID(record), { failPayload });
+  }
+  /**
+   * 渲染进程退出
+   * @param {Electron.Event}                    event   事件对象
+   * @param {XoWindow.Record}                   record  窗口实例
+   * @param {Electron.RenderProcessGoneDetails} details 详情
+   * @returns {Promise<void>}
+   */
+  async onWebContentsRenderProcessGone(event, record, details) {
+    this.xoApp.windowLog.error("\u7A97\u53E3\u6E32\u67D3\u8FDB\u7A0B\u5DF2\u9000\u51FA", WindowUtil.recordToUID(record), { details });
+  }
+  /**
+   * 进入 HTML 全屏
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsEnterHtmlFullScreen(record) {
+  }
+  /**
+   * 退出 HTML 全屏
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Promise<void>}
+   */
+  async onWebContentsLeaveHtmlFullScreen(record) {
+  }
+  /**
+   * 窗口生命周期错误
+   * @param {XoWindow.Record}         record 窗口实例
+   * @param {XoWindow.LifecycleError} error  错误信息
+   * @returns {Promise<void>}
+   */
+  async onError(record, error) {
+    this.xoApp.windowLog.error(`[Lifecycle]`, WindowUtil.recordToUID(record), { error });
+  }
+  /**
+   * 是否是主窗口
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {boolean}
+   * @private
+   */
+  isMainWindow(record) {
+    return record.type.name === MainWindowIdentity.typeName;
+  }
+  /**
+   * 是否是设置窗口
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {boolean}
+   * @private
+   */
+  isSettingWindow(record) {
+    return record.type.name === SettingWindowIdentity.typeName;
+  }
+  /**
+   * 是否是设置窗口
+   * @param {XoWindow.Type} type 窗口类型
+   * @returns {boolean}
+   * @private
+   */
+  isSettingWindowByType(type) {
+    return type.name === SettingWindowIdentity.typeName;
+  }
+  /**
+   * 获取用于持久化的窗口位置和尺寸
+   * @param {XoWindow.Record} record 窗口实例
+   * @returns {Electron.Rectangle}
+   * @private
+   */
+  getWindowRectangle(record) {
+    const bounds = record.window.getBounds();
+    const options = record.type.windowConfig?.browserOptions;
+    if (options?.resizable === false) {
+      return {
+        ...bounds,
+        width: options.width ?? bounds.width,
+        height: options.height ?? bounds.height
+      };
+    }
+    return bounds;
+  }
+  /**
+   * 是否外部触发启动模式
+   * @returns {boolean}
+   * @private
+   */
+  isExternalLaunchMode() {
+    const appConfig = this.xoApp.getAppConfig();
+    return ProtocolUtil.hasProtocolUrl(process.argv, appConfig?.eletronAppConfig?.protocols) || FileAssociationUtil.hasAssociatedFile(process.argv, appConfig?.eletronAppConfig?.fileAssociationExtensions);
+  }
+};
+
+// src/main/window/main/main-window-lifecycle.ts
+var MainWindowLifecycle = class extends WindowLifecycleAbstract {
+};
+
+// src/main/window/main/main-window-type.ts
+var MainWindowType = {
+  name: MainWindowIdentity.typeName,
+  singleInstance: true,
+  windowConfig: defineMainWindowConfig(),
+  lifecycle: MainWindowLifecycle
+};
+
+// src/main/window/setting/setting-window-lifecycle.ts
+var SettingWindowLifecycle = class extends WindowLifecycleAbstract {
+};
+
+// src/main/window/setting/setting-window-type.ts
+var SettingWindowType = {
+  name: SettingWindowIdentity.typeName,
+  singleInstance: true,
+  windowConfig: defineSettingWindowConfig(),
+  lifecycle: SettingWindowLifecycle
+};
+
+// src/main/window/window-manager.ts
+import { BrowserWindow, screen, shell as shell2 } from "electron";
+var WindowManager = class {
+  //<editor-fold desc="内部属性">
+  /** Xion 应用 */
+  xoApp;
+  /** 窗口类型 */
+  types = /* @__PURE__ */ new Map();
+  /** 窗口记录 */
+  records = /* @__PURE__ */ new Map();
+  /** electron 窗口ID -> 窗口标识 */
+  identities = /* @__PURE__ */ new Map();
+  /** 窗口生命周期 */
+  lifecycles = /* @__PURE__ */ new Map();
+  /** 已完成渲染进程首屏渲染的窗口 */
+  rendererReadyWindows = /* @__PURE__ */ new WeakSet();
+  /** 等待渲染进程完成后显示的窗口 */
+  pendingShowWindows = /* @__PURE__ */ new WeakSet();
+  //</editor-fold>
+  //<editor-fold desc="构造函数">
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   * @param {XoWindow.Type[]}  types    窗口类型
+   */
+  constructor(xoApp, types) {
+    this.xoApp = xoApp;
+    this.registerManyType(types);
+    this.registerType(MainWindowType);
+    this.registerType(SettingWindowType);
+  }
+  //</editor-fold>
+  //<editor-fold desc="窗口管理">
+  /**
+   * 复用或创建窗口（如不存在先创建），不显示窗口，仅复用或创建
+   * @param {XoWindow.Identity} identity 窗口标识
+   * @param {XoWindow.Query}    query    URL 查询参数
+   * @returns {Promise<Electron.BrowserWindow>}
+   */
+  async reuseOrCreate(identity, query) {
+    const type = this.ensureGetType(identity.typeName);
+    let record = type.singleInstance ? this.getRecords().find((record2) => record2.type.name === identity.typeName) : this.getRecord(identity.recordId);
+    if (record?.window?.isDestroyed()) {
+      this.removeRecord(record);
+      record = void 0;
+    }
+    const url = this.withQuery(identity.url, query);
+    if (record && record.window) {
+      if (record.url !== url) {
+        record.url = url;
+        await this.getLifecycleByType(record.type)?.loadIndex?.(record);
+      }
+      this.xoApp.windowLog.debug(`\u590D\u7528\u7A97\u53E3`, WindowUtil.recordToUID(record));
+      return record.window;
+    }
+    const window = await this.create({ ...identity, url });
+    record = this.getRecordByBrowserWindowId(window.id);
+    if (record?.window && !record?.window?.isDestroyed()) {
+      this.xoApp.windowLog.debug(`\u521B\u5EFA\u7A97\u53E3`, WindowUtil.recordToUID(record));
+    }
+    return window;
+  }
+  /**
+   * 创建窗口
+   * @param {XoWindow.Identity} identity 窗口标识
+   * @returns {Promise<Electron.BrowserWindow>}
+   */
+  async create(identity) {
+    let record;
+    let window;
+    try {
+      const type = this.ensureGetType(identity.typeName);
+      this.ensureSingleInstanceNotExist(type);
+      this.ensureRecordNotExist(identity.recordId);
+      const identityWinUID = WindowUtil.identityToUID(identity);
+      const options = await this.resolveWindowOptions(type);
+      this.xoApp.windowLog.debug("\u89E3\u6790\u7A97\u53E3\u9009\u9879\u5B8C\u6210", identityWinUID);
+      const lifecycle = this.getLifecycleByType(type);
+      await lifecycle?.beforeCreate(type, options);
+      this.xoApp.windowLog.debug("[\u7A97\u53E3\u521B\u5EFA\u524D]\u751F\u547D\u5468\u671F\u52A0\u8F7D\u5B8C\u6210", identityWinUID);
+      window = new BrowserWindow(options);
+      record = { id: identity.recordId, window, type, url: identity.url };
+      const winUID = WindowUtil.recordToUID(record);
+      this.xoApp.windowLog.debug(`\u7A97\u53E3\u521B\u5EFA\u5B8C\u6210`, winUID);
+      this.addRecord(record);
+      this.addIdentity(window.id, identity);
+      this.xoApp.getThemeManager().syncToWindow(window);
+      this.xoApp.getUpdaterManager().syncToWindowAndCheckForUpdates(window);
+      this.bindLifecycle(record);
+      this.xoApp.windowLog.debug("\u7A97\u53E3\u751F\u547D\u5468\u671F\u7ED1\u5B9A\u5B8C\u6210", winUID);
+      await lifecycle?.afterCreated(record);
+      this.xoApp.windowLog.debug("[\u7A97\u53E3\u521B\u5EFA\u540E]\u751F\u547D\u5468\u671F\u52A0\u8F7D\u5B8C\u6210", winUID);
+      await lifecycle?.loadIndex?.(record);
+      this.xoApp.windowLog.info(`\u7A97\u53E3\u52A0\u8F7D\u5B8C\u6210`, winUID);
+    } catch (error) {
+      this.removeRecord(record);
+      this.removeIdentity(window?.id);
+      this.destroyByWindow(window);
+      this.xoApp.windowLog.error(`\u7A97\u53E3\u521B\u5EFA\u5931\u8D25`, identity, error);
+      await this.dispatchError("WindowManager.create()", record, error);
+      throw error;
+    }
+    return window;
+  }
+  /**
+   * 追加 URL 查询参数
+   * @param {string}         url   原始 URL
+   * @param {XoWindow.Query} query 查询参数
+   * @returns {string}
+   * @private
+   */
+  withQuery(url, query) {
+    if (!query) {
+      return url;
+    }
+    const [pathname, hash = ""] = url.split("#", 2);
+    const [base, search = ""] = pathname.split("?", 2);
+    const params = new URLSearchParams(search);
+    for (const [key, value] of Object.entries(query)) {
+      params.delete(key);
+      const values = Array.isArray(value) ? value : [value];
+      for (const item of values) {
+        if (item === null || item === void 0) {
+          continue;
+        }
+        params.append(key, String(item));
+      }
+    }
+    const nextSearch = params.toString();
+    const nextHash = hash ? `#${hash}` : "";
+    return `${base}${nextSearch ? `?${nextSearch}` : ""}${nextHash}`;
+  }
+  /**
+   * 显示并聚焦窗口
+   * @param {XoWindow.RecordID} id 窗口ID
+   */
+  show(id) {
+    const window = this.getBrowserWindow(id);
+    this.showByWindow(window);
+  }
+  /**
+   * 显示并聚焦窗口
+   * @param {Electron.BrowserWindow} window 窗口对象
+   */
+  showByWindow(window) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    if (this.shouldShowAfterRendererReady(window) && !this.rendererReadyWindows.has(window)) {
+      this.pendingShowWindows.add(window);
+      return;
+    }
+    if (window.isMinimized()) {
+      window.restore();
+    }
+    window.show();
+    window.focus();
+  }
+  /**
+   * 标记渲染进程已完成首屏渲染，并执行此前暂存的显示请求
+   * @param {Electron.BrowserWindow} window 窗口
+   */
+  rendererReady(window) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    this.rendererReadyWindows.add(window);
+    if (!this.pendingShowWindows.has(window)) {
+      return;
+    }
+    this.pendingShowWindows.delete(window);
+    this.showByWindow(window);
+  }
+  /**
+   * 首次渲染开始加载时保持窗口隐藏
+   * @param {Electron.BrowserWindow} window 窗口
+   * @private
+   */
+  rendererLoading(window) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    if (!this.shouldShowAfterRendererReady(window)) {
+      return;
+    }
+    if (this.rendererReadyWindows.has(window)) {
+      return;
+    }
+    if (!window.isVisible()) {
+      return;
+    }
+    this.pendingShowWindows.add(window);
+    window.hide();
+  }
+  /**
+   * 是否等待 Renderer 渲染完成后再显示窗口
+   * @param {Electron.BrowserWindow} window 窗口
+   * @returns {boolean}
+   */
+  shouldShowAfterRendererReady(window) {
+    if (!window || window.isDestroyed()) {
+      return true;
+    }
+    const record = this.getRecordByBrowserWindowId(window.id);
+    return record?.type.windowConfig?.showAfterRendererReady ?? true;
+  }
+  /**
+   * 隐藏窗口
+   * @param {XoWindow.RecordID} id 窗口ID
+   */
+  hide(id) {
+    const window = this.getBrowserWindow(id);
+    this.hideByWindow(window);
+  }
+  /**
+   * 隐藏窗口
+   * @param {Electron.BrowserWindow} window 窗口对象
+   */
+  hideByWindow(window) {
+    if (!window || window?.isDestroyed()) {
+      return;
+    }
+    if (window.isVisible() && !window.isMinimized()) {
+      window.hide();
+    }
+  }
+  /**
+   * 隐藏所有窗口
+   */
+  hideAll() {
+    BrowserWindow.getAllWindows().forEach((window) => {
+      this.hideByWindow(window);
+    });
+  }
+  /**
+   * 切换窗口置顶
+   * @param {XoWindow.RecordID} id 窗口ID
+   */
+  toggleAlwaysOnTop(id) {
+    const window = this.getBrowserWindow(id);
+    this.toggleAlwaysOnTopByWindow(window);
+  }
+  /**
+   * 切换窗口置顶
+   * @param {Electron.BrowserWindow} window 窗口对象
+   */
+  toggleAlwaysOnTopByWindow(window) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    const identity = this.getIdentityByBrowserWindowId(window.id);
+    if (!identity) {
+      return;
+    }
+    const isOnTop = window.isAlwaysOnTop();
+    window.setAlwaysOnTop(!isOnTop);
+    this.xoApp.getAppStore().setWindowOnTop(identity.typeName, !isOnTop);
+    const record = this.getRecordByBrowserWindowId(window.id);
+    record && this.notifyWindowState(record);
+  }
+  /**
+   * 设置全部窗口透明度
+   * @param {number} opacity 窗口透明度
+   */
+  setAllWindowOpacity(opacity) {
+    for (const window of this.getAllBrowserWindow()) {
+      if (!window.isDestroyed()) {
+        window.setOpacity(opacity);
+      }
+    }
+  }
+  /**
+   * 设置全部窗口材质，并实时更新窗口材质
+   * @param {XoApp.WindowMaterial} windowMaterial 窗口材质
+   */
+  setAllWindowMaterial(windowMaterial) {
+    windowMaterial ??= this.getAppWindowMaterial();
+    for (const window of this.getAllBrowserWindow()) {
+      if (window.isDestroyed()) {
+        continue;
+      }
+      const record = this.getRecordByBrowserWindowId(window.id);
+      const options = { ...record?.type.windowConfig?.browserOptions ?? {} };
+      const material = this.resolveWindowMaterial(record?.type, options, windowMaterial);
+      if (material !== void 0) {
+        this.applyWindowMaterialToOptions(options, material);
+      }
+      window.setBackgroundMaterial(options.backgroundMaterial ?? "none");
+      this.xoApp.getThemeManager().syncToWindow(window);
+      record && this.notifyWindowState(record);
+    }
+  }
+  /**
+   * 切换侧边栏折叠
+   * @param {XoWindow.RecordID} id 窗口ID
+   */
+  toggleSidebarFold(id) {
+    const window = this.getBrowserWindow(id);
+    this.toggleSidebarFoldByWindow(window);
+  }
+  /**
+   * 切换侧边栏折叠
+   * @param {Electron.BrowserWindow} window 窗口对象
+   */
+  toggleSidebarFoldByWindow(window) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    const identity = this.getIdentityByBrowserWindowId(window.id);
+    if (!identity) {
+      return;
+    }
+    const isFold = this.xoApp.getAppStore().getSidebarFold(identity.typeName);
+    this.xoApp.getAppStore().setSidebarFold(identity.typeName, !isFold);
+    const record = this.getRecordByBrowserWindowId(window.id);
+    record && this.notifyWindowState(record);
+  }
+  /**
+   * 关闭窗口
+   * @param {XoWindow.RecordID} id 窗口ID
+   */
+  close(id) {
+    const window = this.getBrowserWindow(id);
+    this.closeByWindow(window);
+  }
+  /**
+   * 关闭窗口
+   * @param {Electron.BrowserWindow} window 窗口对象
+   */
+  closeByWindow(window) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    window.close();
+  }
+  /**
+   * 销毁窗口
+   * @param {XoWindow.RecordID} id 窗口ID
+   */
+  destroy(id) {
+    const window = this.getBrowserWindow(id);
+    this.destroyByWindow(window);
+  }
+  /**
+   * 销毁窗口
+   * @param {BrowserWindow} window 窗口对象
+   */
+  destroyByWindow(window) {
+    if (!window || window?.isDestroyed()) {
+      return;
+    }
+    window.destroy();
+  }
+  /**
+   * 关闭所有窗口
+   */
+  closeAll() {
+    for (const window of this.getAllBrowserWindow()) {
+      if (!window.isDestroyed()) {
+        window.close();
+      }
+    }
+  }
+  /**
+   * 重定向窗口路由
+   * @param {XoWindow.RouteRedirectRequest} request 路由重定向请求
+   * @returns {Promise<boolean>}
+   */
+  async redirectRoute(request) {
+    const window = await this.reuseOrCreate(request.windowIdentity);
+    if (window.isDestroyed() || window.webContents.isDestroyed()) {
+      return false;
+    }
+    if (request.focus || request.focus === void 0) {
+      this.showByWindow(window);
+    }
+    window.webContents.send(WindowChannels.onRouteRedirect, request);
+    return true;
+  }
+  //</editor-fold>
+  //<editor-fold desc="窗口类型管理">
+  /**
+   * 注册窗口类型
+   * @param {XoWindow.Type} type 窗口类型
+   */
+  registerType(type) {
+    if (!this.hasType(type.name)) {
+      this.types.set(type.name, type);
+      this.lifecycles.delete(type.name);
+    }
+  }
+  /**
+   * 注册多个窗口类型
+   * @param {XoWindow.Type[]} types 窗口类型
+   */
+  registerManyType(types) {
+    types ??= [];
+    for (const type of types) {
+      this.registerType(type);
+    }
+  }
+  /**
+   * 是否存在窗口类型
+   * @param {XoWindow.TypeName} name 窗口类型名称
+   * @returns {boolean} 是否存在窗口类型
+   */
+  hasType(name) {
+    return this.types.has(name);
+  }
+  /**
+   * 获取窗口类型
+   * @param {XoWindow.TypeName} name 窗口类型名称
+   * @returns {XoWindow.Type | undefined} 窗口类型
+   */
+  getType(name) {
+    return this.types.get(name);
+  }
+  /**
+   * 获取所有窗口类型
+   * @returns {XoWindow.Type[]} 窗口类型
+   */
+  getTypes() {
+    return [...this.types.values()];
+  }
+  /**
+   * 确保获取到窗口类型（如果类型不存在则抛出错误）
+   * @param {XoWindow.TypeName} name 窗口类型名称
+   * @returns {XoWindow.Type} 窗口类型
+   */
+  ensureGetType(name) {
+    const type = this.getType(name);
+    if (type) {
+      return type;
+    }
+    throw new Error(`\u7A97\u53E3\u7C7B\u578B\u672A\u6CE8\u518C: ${name}`);
+  }
+  //</editor-fold>
+  //<editor-fold desc="窗口实例管理">
+  /**
+   * 获取窗口实例
+   * @param {XoWindow.RecordID} id 窗口ID
+   * @returns {XoWindow.Record | undefined}
+   */
+  getRecord(id) {
+    return this.records.get(id);
+  }
+  /**
+   * 获取所有窗口实例
+   * @returns {XoWindow.Record[]}
+   */
+  getRecords() {
+    return [...this.records.values()];
+  }
+  /**
+   * 通过 electron 窗口ID获取窗口实例
+   * @param {number} browserWindowId electron 窗口ID
+   * @returns {XoWindow.Record | undefined}
+   */
+  getRecordByBrowserWindowId(browserWindowId) {
+    const identity = this.getIdentityByBrowserWindowId(browserWindowId);
+    return identity ? this.getRecord(identity.recordId) : void 0;
+  }
+  /**
+   * 添加窗口实例
+   * @param {XoWindow.Record} record 窗口实例
+   */
+  addRecord(record) {
+    this.records.set(record.id, record);
+  }
+  /**
+   * 移除窗口实例
+   * @param {XoWindow.Record} record 窗口实例
+   */
+  removeRecord(record) {
+    if (!record?.id) {
+      return;
+    }
+    const current = this.records.get(record.id);
+    if (current?.window === record?.window) {
+      this.records.delete(record.id);
+      this.removeIdentity(record.window?.id);
+    }
+  }
+  /**
+   * 确保窗口实例不存在，如果窗口实例存在则报错
+   * @param {XoWindow.RecordID} id 窗口ID
+   * @private
+   */
+  ensureRecordNotExist(id) {
+    if (this.getRecord(id)) {
+      throw new Error(`\u7A97\u53E3ID\u5DF2\u5B58\u5728: ${id}`);
+    }
+  }
+  /**
+   * 确保单例窗口不存在，如果单例窗口存在则报错
+   * @param {XoWindow.Type} type 窗口类型
+   * @private
+   */
+  ensureSingleInstanceNotExist(type) {
+    if (!type.singleInstance) {
+      return;
+    }
+    const record = this.getRecords().find((record2) => record2.type.name === type.name);
+    if (record?.window?.isDestroyed()) {
+      this.removeRecord(record);
+      return;
+    }
+    if (record) {
+      throw new Error(`\u5355\u4F8B\u7A97\u53E3\u5DF2\u5B58\u5728: ${type.name}`);
+    }
+  }
+  //</editor-fold>
+  //<editor-fold desc="electron 窗口对象">
+  /**
+   * 获取 electron 窗口对象
+   * @param {XoWindow.RecordID} id 窗口ID
+   * @returns {Electron.BrowserWindow | undefined}
+   */
+  getBrowserWindow(id) {
+    return this.getRecord(id)?.window;
+  }
+  /**
+   * 获取指定窗口类型的 electron 窗口对象（如果有多个，也仅返回第1个）
+   * @param {XoWindow.TypeName} typeName 窗口类型名称
+   * @returns {Electron.BrowserWindow | undefined}
+   */
+  getFirstBrowserWindowByType(typeName) {
+    return this.getRecords().find((record) => record.type.name === typeName)?.window;
+  }
+  /**
+   * 获取所有 electron 窗口对象
+   * @returns {Electron.BrowserWindow[]}
+   */
+  getAllBrowserWindow() {
+    return this.getRecords().map((record) => record.window);
+  }
+  /**
+   * 获取窗口状态
+   * @param {Electron.BrowserWindow} window 窗口对象
+   * @returns {XoWindow.State}
+   */
+  getWindowState(window) {
+    let isSidebarFolded = false;
+    let windowMaterial;
+    if (window && !window.isDestroyed()) {
+      const identity = this.getIdentityByBrowserWindowId(window.id);
+      if (identity) {
+        isSidebarFolded = this.xoApp.getAppStore().getSidebarFold(identity.typeName);
+      }
+      const record = this.getRecordByBrowserWindowId(window.id);
+      const options = { ...record?.type.windowConfig?.browserOptions ?? {} };
+      windowMaterial = this.resolveWindowMaterial(record?.type, options);
+      windowMaterial ??= "none";
+    }
+    return {
+      windowMaterial,
+      isSidebarFolded,
+      isAlwaysOnTop: window?.isAlwaysOnTop() ?? false,
+      isMaximized: window?.isMaximized() ?? false,
+      isFullScreen: window?.isFullScreen() ?? false,
+      isMinimized: window?.isMinimized() ?? false,
+      isFullScreenable: window?.isFullScreenable() ?? false,
+      isMinimizable: window?.isMinimizable() ?? false,
+      isMaximizable: window?.isMaximizable() ?? false,
+      isClosable: window?.isClosable() ?? false
+    };
+  }
+  /**
+   * 通知窗口状态
+   * @param {XoWindow.Record} record 窗口实例
+   */
+  notifyWindowState(record) {
+    setTimeout(() => {
+      const window = record.window;
+      if (window.isDestroyed() || window.webContents.isDestroyed()) {
+        return;
+      }
+      window.webContents.send(WindowChannels.onState, this.getWindowState(window));
+    });
+  }
+  /**
+   * 解析窗口选项
+   * @param {XoWindow.Type} type 窗口类型
+   * @returns {Promise<Electron.BrowserWindowConstructorOptions>}
+   * @private
+   */
+  async resolveWindowOptions(type) {
+    const options = { ...type?.windowConfig?.browserOptions ?? {} };
+    const productName = this.xoApp.getAppConfig()?.eletronAppConfig?.productName;
+    if (options.title === void 0 && productName) {
+      if (type.name === MainWindowType.name) {
+        options.title = productName;
+      } else if (type.name === SettingWindowType.name) {
+        options.title = `${productName} \u8BBE\u7F6E`;
+      }
+    }
+    const appStore = this.xoApp.getAppStore();
+    const rectangle = appStore.getWindowRectangle(type.name);
+    const isOnTop = appStore.getWindowOnTop(type.name);
+    const opacity = appStore.getOpacity();
+    const windowMaterial = this.resolveWindowMaterial(type, options);
+    if (windowMaterial !== void 0) {
+      this.applyWindowMaterialToOptions(options, windowMaterial);
+    }
+    if (!this.needsTransparentBackground(options)) {
+      options.backgroundColor ??= this.xoApp.getThemeManager().titleBarOverlay().color;
+    }
+    options.opacity = opacity;
+    options.alwaysOnTop = isOnTop;
+    if (rectangle) {
+      this.restoreWindowRectangle(options, rectangle);
+    }
+    return options;
+  }
+  /**
+   * 是否需要透明窗口背景
+   * @param {Electron.BrowserWindowConstructorOptions} options 窗口选项
+   * @returns {boolean}
+   * @private
+   */
+  needsTransparentBackground(options) {
+    return options.transparent === true || options.backgroundMaterial !== void 0 && options.backgroundMaterial !== "none";
+  }
+  /**
+   * 解析快捷窗口材质
+   * @param {XoWindow.Type}                              type              窗口类型
+   * @param {Electron.BrowserWindowConstructorOptions}   options           窗口选项
+   * @param {XoApp.WindowMaterial | undefined}           appWindowMaterial APP 级窗口材质
+   * @returns {XoApp.WindowMaterial | undefined}
+   * @private
+   */
+  resolveWindowMaterial(type, options, appWindowMaterial = this.getAppWindowMaterial()) {
+    if (options.backgroundMaterial !== void 0) {
+      return void 0;
+    }
+    return type?.windowConfig?.windowMaterial ?? appWindowMaterial;
+  }
+  /**
+   * 获取 APP 级快捷窗口材质
+   * @returns {XoApp.WindowMaterial | undefined}
+   * @private
+   */
+  getAppWindowMaterial() {
+    return this.xoApp.getAppStore().getWindowMaterial() ?? this.xoApp.getAppConfig()?.windowMaterial;
+  }
+  /**
+   * 利用快捷窗口材质更新窗口材质相关选项
+   * @param {Electron.BrowserWindowConstructorOptions} options        窗口选项
+   * @param {XoApp.WindowMaterial}                     windowMaterial 窗口材质
+   * @private
+   */
+  applyWindowMaterialToOptions(options, windowMaterial) {
+    if (windowMaterial === "transparent") {
+      options.backgroundMaterial = "none";
+      options.transparent = true;
+      options.backgroundColor = "#00000000";
+      options.frame = false;
+      options.thickFrame = false;
+      return;
+    }
+    if (windowMaterial === "none") {
+      options.backgroundMaterial = "none";
+      options.transparent = false;
+      return;
+    }
+    options.backgroundMaterial = windowMaterial;
+    options.transparent = false;
+    options.backgroundColor = "#00000000";
+  }
+  /**
+   * 确保窗口有足够区域在屏幕可视范围内
+   * @param {Electron.BrowserWindow} window          窗口对象
+   * @param {Electron.BrowserWindow} referenceWindow 参考窗口
+   */
+  ensureWindowRectangleVisible(window, referenceWindow) {
+    if (!window || window.isDestroyed()) {
+      return;
+    }
+    const rectangle = window.getBounds();
+    if (referenceWindow && !referenceWindow.isDestroyed()) {
+      const display = screen.getDisplayMatching(referenceWindow.getBounds());
+      if (!this.isWindowRectangleVisibleInDisplay(rectangle, display)) {
+        this.centerWindow(window, display);
+      }
+      return;
+    }
+    if (!this.isWindowRectangleVisible(rectangle)) {
+      this.centerWindow(window, this.resolveCenterDisplay(rectangle));
+    }
+  }
+  /**
+   * 恢复窗口位置和尺寸
+   * @param {Electron.BrowserWindowConstructorOptions} options   窗口选项
+   * @param {Electron.Rectangle}                       rectangle 窗口位置和大小
+   * @private
+   */
+  restoreWindowRectangle(options, rectangle) {
+    if (options.resizable !== false) {
+      options.width = rectangle.width ?? options.width;
+      options.height = rectangle.height ?? options.height;
+    }
+    if (this.isWindowRectangleVisible(rectangle)) {
+      options.x = rectangle.x;
+      options.y = rectangle.y;
+      return;
+    }
+    this.centerWindowOptions(options, this.resolveCenterDisplay(rectangle));
+  }
+  /**
+   * 窗口是否有足够区域在屏幕可视范围内
+   * @param {Electron.Rectangle} rectangle 窗口位置和大小
+   * @returns {boolean}
+   * @private
+   */
+  isWindowRectangleVisible(rectangle) {
+    return screen.getAllDisplays().some((display) => this.isWindowRectangleVisibleInDisplay(rectangle, display));
+  }
+  /**
+   * 窗口是否有足够区域在指定屏幕可视范围内
+   * @param {Electron.Rectangle} rectangle 窗口位置和大小
+   * @param {Electron.Display}   display   屏幕
+   * @returns {boolean}
+   * @private
+   */
+  isWindowRectangleVisibleInDisplay(rectangle, display) {
+    const minVisibleSize = 200;
+    const area = display.workArea;
+    const visibleWidth = Math.min(rectangle.x + rectangle.width, area.x + area.width) - Math.max(rectangle.x, area.x);
+    const visibleHeight = Math.min(rectangle.y + rectangle.height, area.y + area.height) - Math.max(rectangle.y, area.y);
+    return visibleWidth >= minVisibleSize && visibleHeight >= minVisibleSize;
+  }
+  /**
+   * 解析居中目标屏幕
+   * @param {Electron.Rectangle} rectangle 窗口位置和大小
+   * @returns {Electron.Display}
+   * @private
+   */
+  resolveCenterDisplay(rectangle) {
+    const center = {
+      x: rectangle.x + rectangle.width / 2,
+      y: rectangle.y + rectangle.height / 2
+    };
+    if (!this.isPointInAnyDisplay(center)) {
+      return screen.getPrimaryDisplay();
+    }
+    return screen.getDisplayNearestPoint(center);
+  }
+  /**
+   * 坐标点是否在任一屏幕范围内
+   * @param {Electron.Point} point 坐标点
+   * @returns {boolean}
+   * @private
+   */
+  isPointInAnyDisplay(point) {
+    return screen.getAllDisplays().some((display) => {
+      const bounds = display.bounds;
+      return point.x >= bounds.x && point.x <= bounds.x + bounds.width && point.y >= bounds.y && point.y <= bounds.y + bounds.height;
+    });
+  }
+  /**
+   * 将窗口居中到指定屏幕
+   * @param {Electron.BrowserWindow} window  窗口对象
+   * @param {Electron.Display}       display 屏幕
+   * @private
+   */
+  centerWindow(window, display) {
+    const area = display.workArea;
+    const bounds = window.getBounds();
+    const x = Math.round(area.x + (area.width - bounds.width) / 2);
+    const y = Math.round(area.y + (area.height - bounds.height) / 2);
+    window.setPosition(x, y);
+  }
+  /**
+   * 将窗口选项居中到指定屏幕
+   * @param {Electron.BrowserWindowConstructorOptions} options 窗口选项
+   * @param {Electron.Display}                         display 屏幕
+   * @private
+   */
+  centerWindowOptions(options, display) {
+    const area = display.workArea;
+    const width = options.width ?? 800;
+    const height = options.height ?? 600;
+    options.x = Math.round(area.x + (area.width - width) / 2);
+    options.y = Math.round(area.y + (area.height - height) / 2);
+    options.center = false;
+  }
+  //</editor-fold>
+  //<editor-fold desc="窗口标识管理">
+  /**
+   * 添加窗口标识
+   * @param {number}            browserWindowId electron 窗口ID
+   * @param {XoWindow.Identity} identity        窗口标识
+   * @private
+   */
+  addIdentity(browserWindowId, identity) {
+    this.identities.set(browserWindowId, identity);
+  }
+  /**
+   * 移除窗口标识
+   * @param {number | undefined} browserWindowId electron 窗口ID
+   * @private
+   */
+  removeIdentity(browserWindowId) {
+    if (browserWindowId === void 0) {
+      return;
+    }
+    this.identities.delete(browserWindowId);
+  }
+  /**
+   * 通过 electron 窗口ID获取窗口标识
+   * @param {number} browserWindowId electron 窗口ID
+   * @returns {XoWindow.Identity | undefined}
+   */
+  getIdentityByBrowserWindowId(browserWindowId) {
+    return this.identities.get(browserWindowId);
+  }
+  /**
+   * 获取当前已打开窗口标识
+   * @returns {XoWindow.Identity[]}
+   */
+  getOpenedWindowIdentities() {
+    return [...this.identities.values()];
+  }
+  //</editor-fold>
+  //<editor-fold desc="生命周期">
+  /**
+   * 获取窗口生命周期
+   * @param {XoWindow.Type} type 窗口类型
+   * @returns {WindowLifecycleAbstract | undefined} 窗口生命周期
+   * @private
+   */
+  getLifecycleByType(type) {
+    if (!type.lifecycle) {
+      return void 0;
+    }
+    let lifecycle = this.lifecycles.get(type.name);
+    if (!lifecycle) {
+      lifecycle = new type.lifecycle(this.xoApp);
+      this.lifecycles.set(type.name, lifecycle);
+    }
+    return lifecycle;
+  }
+  /**
+   * 绑定窗口生命周期
+   * @param {XoWindow.Record} record 窗口记录
+   */
+  bindLifecycle(record) {
+    const { type, window } = record;
+    const winUID = WindowUtil.recordToUID(record);
+    this.bindWindowOpenHandler(window);
+    const lifecycle = this.getLifecycleByType(type);
+    window.on("closed", () => {
+      this.removeRecord(record);
+      this.xoApp.windowLog.debug("on:closed", winUID);
+      if (lifecycle) {
+        this.catcher("on:closed", record, () => lifecycle.onClosed(record));
+      }
+    });
+    if (!lifecycle) {
+      return;
+    }
+    window.once("ready-to-show", () => {
+      this.xoApp.windowLog.debug("once:ready-to-show", winUID);
+      this.catcher("once:ready-to-show", record, () => lifecycle.onceReadyToShow(record));
+    });
+    window.on("show", () => {
+      this.xoApp.windowLog.debug("on:show", winUID);
+      this.catcher("on:show", record, () => lifecycle.onShow(record));
+    });
+    window.on("hide", () => {
+      this.xoApp.windowLog.debug("on:hide", winUID);
+      this.catcher("on:hide", record, () => lifecycle.onHide(record));
+    });
+    window.on("focus", (event) => {
+      this.xoApp.windowLog.debug("on:focus", winUID);
+      this.catcher("on:focus", record, () => lifecycle.onFocus(event, record));
+    });
+    window.on("blur", (event) => {
+      this.xoApp.windowLog.debug("on:blur", winUID);
+      this.catcher("on:blur", record, () => lifecycle.onBlur(event, record));
+    });
+    window.on("resize", () => {
+      this.xoApp.windowLog.debug("on:resize", winUID);
+      this.catcher("on:resize", record, () => lifecycle.onResize(record));
+    });
+    window.on("resized", () => {
+      this.xoApp.windowLog.debug("on:resized", winUID);
+      this.catcher("on:resized", record, () => lifecycle.onResized(record));
+    });
+    window.on("move", () => {
+      if (type?.windowConfig?.debugPosition) {
+        this.xoApp.windowLog.debug("on:move", winUID);
+      }
+      this.catcher("on:move", record, () => lifecycle.onMove(record));
+    });
+    window.on("moved", () => {
+      if (type?.windowConfig?.debugPosition) {
+        this.xoApp.windowLog.debug("on:moved", winUID);
+      }
+      this.catcher("on:moved", record, () => lifecycle.onMoved(record));
+    });
+    window.on("maximize", () => {
+      this.xoApp.windowLog.debug("on:maximize", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:maximize", record, () => lifecycle.onMaximize(record));
+    });
+    window.on("unmaximize", () => {
+      this.xoApp.windowLog.debug("on:unmaximize", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:unmaximize", record, () => lifecycle.onUnmaximize(record));
+    });
+    window.on("minimize", () => {
+      this.xoApp.windowLog.debug("on:minimize", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:minimize", record, () => lifecycle.onMinimize(record));
+    });
+    window.on("restore", () => {
+      this.xoApp.windowLog.debug("on:restore", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:restore", record, () => lifecycle.onRestore(record));
+    });
+    window.on("enter-full-screen", () => {
+      this.xoApp.windowLog.debug("on:enter-full-screen", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:enter-full-screen", record, () => lifecycle.onEnterFullScreen(record));
+    });
+    window.on("leave-full-screen", () => {
+      this.xoApp.windowLog.debug("on:leave-full-screen", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:leave-full-screen", record, () => lifecycle.onLeaveFullScreen(record));
+    });
+    window.on("always-on-top-changed", () => {
+      this.xoApp.windowLog.debug("on:always-on-top-changed", winUID);
+      this.notifyWindowState(record);
+      this.catcher("on:always-on-top-changed", record, () => lifecycle.onAlwaysOnTopChanged(record));
+    });
+    window.on("close", (event) => {
+      this.xoApp.windowLog.debug("on:close", winUID);
+      this.catcher("on:close", record, () => lifecycle.onClose(event, record));
+    });
+    window.on("unresponsive", () => {
+      this.xoApp.windowLog.debug("on:unresponsive", winUID);
+      this.catcher("on:unresponsive", record, () => lifecycle.onUnresponsive(record));
+    });
+    window.on("responsive", () => {
+      this.xoApp.windowLog.debug("on:responsive", winUID);
+      this.catcher("on:responsive", record, () => lifecycle.onResponsive(record));
+    });
+    window.webContents.on("page-favicon-updated", (event, favicons) => {
+      this.xoApp.windowLog.debug("on:page-favicon-updated", winUID);
+      this.catcher("on:page-favicon-updated", record, () => lifecycle.onWebContentsPageFaviconUpdated(event, record, favicons));
+    });
+    window.webContents.on("focus", () => {
+      this.xoApp.windowLog.debug("on:focus", winUID);
+      this.catcher("on:focus", record, () => lifecycle.onWebContentsFocus(record));
+    });
+    window.webContents.on("blur", () => {
+      this.xoApp.windowLog.debug("on:blur", winUID);
+      this.catcher("on:blur", record, () => lifecycle.onWebContentsBlur(record));
+    });
+    window.webContents.on("did-change-theme-color", (event, color) => {
+      this.xoApp.windowLog.debug("on:did-change-theme-color", winUID);
+      this.catcher("on:did-change-theme-color", record, () => lifecycle.onWebContentsDidChangeThemeColor(event, record, color));
+    });
+    window.webContents.on("update-target-url", (event, url) => {
+      this.xoApp.windowLog.debug("on:update-target-url", winUID);
+      this.catcher("on:update-target-url", record, () => lifecycle.onWebContentsUpdateTargetUrl(event, record, url));
+    });
+    window.webContents.on("will-navigate", (event, url) => {
+      const shouldOpenExternal = this.shouldOpenExternal(url, window.webContents.getURL());
+      this.xoApp.windowLog.debug("on:will-navigate", winUID, { url, shouldOpenExternal });
+      this.catcher("on:will-navigate", record, () => lifecycle.onWebContentsWillNavigate(event, record, url, shouldOpenExternal));
+    });
+    window.webContents.on("context-menu", (event, params) => {
+      this.xoApp.windowLog.debug("on:context-menu", winUID);
+      this.catcher("on:context-menu", record, () => lifecycle.onWebContentsContextMenu(event, record, params));
+    });
+    window.webContents.on("before-input-event", (event, input) => {
+      this.xoApp.windowLog.debug("on:before-input-event", winUID);
+      this.catcher("on:before-input-event", record, () => lifecycle.onWebContentsBeforeInputEvent(event, record, input));
+    });
+    window.webContents.on("input-event", (event, inputEvent) => {
+      if (type?.windowConfig?.debugInputEvent) {
+        this.xoApp.windowLog.debug("on:input-event", winUID);
+      }
+      this.catcher("on:input-event", record, () => lifecycle.onWebContentsInputEvent(event, record, inputEvent));
+    });
+    window.webContents.on("devtools-open-url", (event, url) => {
+      this.xoApp.windowLog.debug("on:devtools-open-url", winUID);
+      this.catcher("on:devtools-open-url", record, () => lifecycle.onWebContentsDevtoolsOpenUrl(event, record, url));
+    });
+    window.webContents.on("devtools-search-query", (event, query) => {
+      this.xoApp.windowLog.debug("on:devtools-search-query", winUID);
+      this.catcher("on:devtools-search-query", record, () => lifecycle.onWebContentsDevtoolsSearchQuery(event, record, query));
+    });
+    window.webContents.on("devtools-opened", () => {
+      this.xoApp.windowLog.debug("on:devtools-opened", winUID);
+      this.catcher("on:devtools-opened", record, () => lifecycle.onWebContentsDevtoolsOpened(record));
+    });
+    window.webContents.on("devtools-closed", () => {
+      this.xoApp.windowLog.debug("on:devtools-closed", winUID);
+      this.catcher("on:devtools-closed", record, () => lifecycle.onWebContentsDevtoolsClosed(record));
+    });
+    window.webContents.on("devtools-focused", () => {
+      this.xoApp.windowLog.debug("on:devtools-focused", winUID);
+      this.catcher("on:devtools-focused", record, () => lifecycle.onWebContentsDevtoolsFocused(record));
+    });
+    window.webContents.on("certificate-error", (event, url, error, certificate, callback, isMainFrame) => {
+      this.xoApp.windowLog.debug("on:certificate-error", winUID);
+      this.catcher("on:certificate-error", record, () => lifecycle.onWebContentsCertificateError(
+        event,
+        record,
+        url,
+        error,
+        certificate,
+        callback,
+        isMainFrame
+      ));
+    });
+    window.webContents.on("select-client-certificate", (event, url, certificateList, callback) => {
+      this.xoApp.windowLog.debug("on:select-client-certificate", winUID);
+      this.catcher("on:select-client-certificate", record, () => lifecycle.onWebContentsSelectClientCertificate(
+        event,
+        record,
+        url,
+        certificateList,
+        callback
+      ));
+    });
+    window.webContents.on("login", (event, authenticationResponseDetails, authInfo, callback) => {
+      this.xoApp.windowLog.debug("on:login", winUID);
+      this.catcher("on:login", record, () => lifecycle.onWebContentsLogin(
+        event,
+        record,
+        authenticationResponseDetails,
+        authInfo,
+        callback
+      ));
+    });
+    window.webContents.on("found-in-page", (event, result) => {
+      this.xoApp.windowLog.debug("on:found-in-page", winUID);
+      this.catcher("on:found-in-page", record, () => lifecycle.onWebContentsFoundInPage(event, record, result));
+    });
+    window.webContents.on("media-started-playing", () => {
+      this.xoApp.windowLog.debug("on:media-started-playing", winUID);
+      this.catcher("on:media-started-playing", record, () => lifecycle.onWebContentsMediaStartedPlaying(record));
+    });
+    window.webContents.on("media-paused", () => {
+      this.xoApp.windowLog.debug("on:media-paused", winUID);
+      this.catcher("on:media-paused", record, () => lifecycle.onWebContentsMediaPaused(record));
+    });
+    window.webContents.on("audio-state-changed", (event) => {
+      this.xoApp.windowLog.debug("on:audio-state-changed", winUID);
+      this.catcher("on:audio-state-changed", record, () => lifecycle.onWebContentsAudioStateChanged(event, record));
+    });
+    window.webContents.on("console-message", (details) => {
+      if (type?.windowConfig?.debugConsole) {
+        this.xoApp.windowLog.debug("on:console-message", winUID);
+      }
+      this.catcher("on:console-message", record, () => lifecycle.onWebContentsConsoleMessage(details, record));
+    });
+    window.webContents.on("preload-error", (event, preloadPath, error) => {
+      this.xoApp.windowLog.debug("on:preload-error", winUID);
+      this.catcher("on:preload-error", record, () => lifecycle.onWebContentsPreloadError(event, record, preloadPath, error));
+    });
+    window.webContents.on("ipc-message", (event, channel, ...args) => {
+      if (type?.windowConfig?.debugIpcMessage) {
+        this.xoApp.windowLog.debug("on:ipc-message", winUID);
+      }
+      this.catcher("on:ipc-message", record, () => lifecycle.onWebContentsIpcMessage(event, record, channel, ...args));
+    });
+    window.webContents.on("ipc-message-sync", (event, channel, ...args) => {
+      if (type?.windowConfig?.debugIpcMessage) {
+        this.xoApp.windowLog.debug("on:ipc-message-sync", winUID);
+      }
+      this.catcher("on:ipc-message-sync", record, () => lifecycle.onWebContentsIpcMessageSync(event, record, channel, ...args));
+    });
+    window.webContents.on("preferred-size-changed", (event, preferredSize) => {
+      this.xoApp.windowLog.debug("on:preferred-size-changed", winUID);
+      this.catcher("on:preferred-size-changed", record, () => lifecycle.onWebContentsPreferredSizeChanged(event, record, preferredSize));
+    });
+    window.webContents.on("frame-created", (event, details) => {
+      this.xoApp.windowLog.debug("on:frame-created", winUID);
+      this.catcher("on:frame-created", record, () => lifecycle.onWebContentsFrameCreated(event, record, details));
+    });
+    window.webContents.on("will-attach-webview", (event, webPreferences, params) => {
+      this.xoApp.windowLog.debug("on:will-attach-webview", winUID);
+      this.catcher("on:will-attach-webview", record, () => lifecycle.onWebContentsWillAttachWebview(
+        event,
+        record,
+        webPreferences,
+        params
+      ));
+    });
+    window.webContents.on("did-attach-webview", (event, webContents) => {
+      this.xoApp.windowLog.debug("on:did-attach-webview", winUID);
+      this.catcher("on:did-attach-webview", record, () => lifecycle.onWebContentsDidAttachWebview(event, record, webContents));
+    });
+    window.webContents.on("paint", (details, dirtyRect, image) => {
+      this.xoApp.windowLog.debug("on:paint", winUID);
+      this.catcher("on:paint", record, () => lifecycle.onWebContentsPaint(details, record, dirtyRect, image));
+    });
+    window.webContents.on("devtools-reload-page", () => {
+      this.xoApp.windowLog.debug("on:devtools-reload-page", winUID);
+      this.catcher("on:devtools-reload-page", record, () => lifecycle.onWebContentsDevtoolsReloadPage(record));
+    });
+    window.webContents.on("destroyed", () => {
+      this.xoApp.windowLog.debug("on:destroyed", winUID);
+      this.catcher("on:destroyed", record, () => lifecycle.onWebContentsDestroyed(record));
+    });
+    window.webContents.on("did-finish-load", () => {
+      this.xoApp.windowLog.debug("on:did-finish-load", winUID);
+      this.catcher("on:did-finish-load", record, () => lifecycle.onWebContentsDidFinishLoad(record));
+    });
+    window.webContents.on("did-start-loading", () => {
+      this.xoApp.windowLog.debug("on:did-start-loading", winUID);
+      this.rendererLoading(window);
+      this.catcher("on:did-start-loading", record, () => lifecycle.onWebContentsDidStartLoading(record));
+    });
+    window.webContents.on("did-stop-loading", () => {
+      this.xoApp.windowLog.debug("on:did-stop-loading", winUID);
+      this.catcher("on:did-stop-loading", record, () => lifecycle.onWebContentsDidStopLoading(record));
+    });
+    window.webContents.on("dom-ready", () => {
+      this.xoApp.windowLog.debug("on:dom-ready", winUID);
+      this.catcher("on:dom-ready", record, () => lifecycle.onWebContentsDomReady(record));
+    });
+    window.webContents.on("page-title-updated", (event, title, explicitSet) => {
+      this.xoApp.windowLog.debug("on:page-title-updated", winUID);
+      this.catcher("on:page-title-updated", record, () => lifecycle.onWebContentsPageTitleUpdated(event, record, title, explicitSet));
+    });
+    window.webContents.on("did-fail-load", (event, errorCode, errorDescription, validatedURL, isMainFrame, frameProcessId, frameRoutingId) => {
+      const params = {
+        errorCode,
+        errorDescription,
+        validatedURL,
+        isMainFrame,
+        frameProcessId,
+        frameRoutingId
+      };
+      this.xoApp.windowLog.debug("on:did-fail-load", winUID, { ...params });
+      this.catcher("on:did-fail-load", record, () => lifecycle.onWebContentsDidFailLoad(event, record, params));
+    });
+    window.webContents.on("enter-html-full-screen", () => {
+      this.xoApp.windowLog.debug("on:enter-html-full-screen", winUID);
+      this.catcher("on:enter-html-full-screen", record, () => lifecycle.onWebContentsEnterHtmlFullScreen(record));
+    });
+    window.webContents.on("leave-html-full-screen", () => {
+      this.xoApp.windowLog.debug("on:leave-html-full-screen", winUID);
+      this.catcher("on:leave-html-full-screen", record, () => lifecycle.onWebContentsLeaveHtmlFullScreen(record));
+    });
+    window.webContents.on("render-process-gone", (event, details) => {
+      this.xoApp.windowLog.debug("on:render-process-gone", winUID, { details });
+      this.catcher("on:render-process-gone", record, () => lifecycle.onWebContentsRenderProcessGone(event, record, details));
+    });
+  }
+  /**
+   * 绑定新窗口打开拦截
+   * @param {Electron.BrowserWindow} window 窗口对象
+   * @private
+   */
+  bindWindowOpenHandler(window) {
+    window.webContents.setWindowOpenHandler((details) => {
+      if (!this.shouldOpenExternal(details.url, window.webContents.getURL())) {
+        return { action: "allow" };
+      }
+      void shell2.openExternal(details.url);
+      return { action: "deny" };
+    });
+  }
+  /**
+   * 是否应使用系统浏览器打开
+   * @param {string} targetURL  目标地址
+   * @param {string} currentURL 当前地址
+   * @returns {boolean}
+   * @private
+   */
+  shouldOpenExternal(targetURL, currentURL) {
+    const appConfig = this.xoApp.getAppConfig();
+    if (!appConfig?.takeOverLinkNavigation) {
+      return false;
+    }
+    if (this.isLinkNavigationWhiteListed(targetURL)) {
+      return false;
+    }
+    const target = this.parseURL(targetURL);
+    if (!target) {
+      return false;
+    }
+    if (["mailto:", "tel:"].includes(target.protocol)) {
+      return true;
+    }
+    if (!["http:", "https:"].includes(target.protocol)) {
+      return false;
+    }
+    const current = this.parseURL(currentURL);
+    if (!current) {
+      return true;
+    }
+    return target.origin !== current.origin;
+  }
+  /**
+   * 是否命中链接跳转白名单
+   * @param {string} url 链接
+   * @returns {boolean}
+   * @private
+   */
+  isLinkNavigationWhiteListed(url) {
+    return this.xoApp.getAppConfig()?.linkNavigationWhiteList?.some((pattern) => pattern.test(url)) ?? false;
+  }
+  /**
+   * 解析 URL
+   * @param {string} value URL
+   * @returns {URL | undefined}
+   * @private
+   */
+  parseURL(value) {
+    try {
+      return new URL(value);
+    } catch {
+      return void 0;
+    }
+  }
+  //</editor-fold>
+  //<editor-fold desc="错误管理">
+  /**
+   * 事件错误捕捉器
+   * @param {string}                       source 事件来源
+   * @param {XoWindow.Record}              record 窗口实例
+   * @param {() => (Promise<void> | void)} runner 事件处理器
+   * @private
+   */
+  catcher(source, record, runner) {
+    try {
+      void Promise.resolve(runner()).catch((error) => {
+        void this.getLifecycleByType(record.type)?.onError(record, { source, error });
+      });
+    } catch (error) {
+      void this.getLifecycleByType(record.type)?.onError(record, { source, error });
+    }
+  }
+  /**
+   * 分发错误
+   * @param {string}                      source 来源
+   * @param {XoWindow.Record | undefined} record 窗口实例
+   * @param {unknown}                     error  错误对象
+   * @returns {Promise<void>}
+   * @private
+   */
+  async dispatchError(source, record, error) {
+    if (record) {
+      await this.getLifecycleByType(record.type)?.onError(record, { source, error });
+      return;
+    }
+    await this.xoApp.dispatchAppError({ source, error });
+  }
+  //</editor-fold>
+};
+
+export {
+  WindowLifecycleAbstract,
+  MainWindowLifecycle,
+  MainWindowType,
+  SettingWindowLifecycle,
+  SettingWindowType,
+  WindowManager
+};