@e-xi/xion 0.0.6

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

@@ -0,0 +1,1243 @@
+import {
+  BridgeUtil
+} from "./chunk-PL5KNBCY.js";
+import {
+  AppChannels,
+  ClipboardChannels,
+  DialogChannels,
+  FileChannels,
+  LogChannels,
+  ShellChannels
+} from "./chunk-RAVPJRBA.js";
+import {
+  UpdaterChannels
+} from "./chunk-LQ67F6EY.js";
+import {
+  ContextMenuChannels,
+  WindowChannels
+} from "./chunk-BFD2LHLK.js";
+import {
+  LogUtil
+} from "./chunk-BMOLIJ3W.js";
+import {
+  RemoteServiceChannels
+} from "./chunk-RN7AI33H.js";
+import {
+  ThemeChannels
+} from "./chunk-UIJUY7QZ.js";
+import {
+  AuthChannels
+} from "./chunk-T3QCAOCO.js";
+
+// src/preload/bridge/bridge-abstract.ts
+var BridgeAbstract = class {
+};
+
+// src/preload/bridges/app/app-bridge.ts
+var AppBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.app}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      app: {
+        // 获取应用信息
+        getInfo: this.getInfo.bind(this),
+        // 获取应用目录
+        getPaths: this.getPaths.bind(this),
+        // 获取通用设置
+        getGeneralSettings: this.getGeneralSettings.bind(this),
+        // 获取 APP 透明度
+        getOpacity: this.getOpacity.bind(this),
+        // 设置 APP 透明度
+        setOpacity: this.setOpacity.bind(this),
+        // 获取快捷窗口材质
+        getWindowMaterial: this.getWindowMaterial.bind(this),
+        // 设置快捷窗口材质
+        setWindowMaterial: this.setWindowMaterial.bind(this),
+        // 获取应用启动模式
+        getAppLaunchMode: this.getAppLaunchMode.bind(this),
+        // 设置应用启动模式
+        setAppLaunchMode: this.setAppLaunchMode.bind(this),
+        // 获取是否开机启动
+        getLaunchOnStartup: this.getLaunchOnStartup.bind(this),
+        // 设置是否开机启动
+        setLaunchOnStartup: this.setLaunchOnStartup.bind(this),
+        // 获取关闭窗口行为
+        getWindowCloseBehavior: this.getWindowCloseBehavior.bind(this),
+        // 设置关闭窗口行为
+        setWindowCloseBehavior: this.setWindowCloseBehavior.bind(this),
+        // 获取日志等级
+        getLogLevel: this.getLogLevel.bind(this),
+        // 设置日志等级
+        setLogLevel: this.setLogLevel.bind(this),
+        // 获取快捷键配置
+        getShortcuts: this.getShortcuts.bind(this),
+        // 设置快捷键配置
+        setShortcuts: this.setShortcuts.bind(this),
+        // 设置单个快捷键配置
+        setShortcut: this.setShortcut.bind(this),
+        // 删除快捷键配置
+        deleteShortcut: this.deleteShortcut.bind(this),
+        // 重定向指定窗口路由
+        redirectWindowRoute: this.redirectWindowRoute.bind(this),
+        // 重定向主窗口路由
+        redirectMainWindowRoute: this.redirectMainWindowRoute.bind(this),
+        // 重定向设置窗口路由
+        redirectSettingWindowRoute: this.redirectSettingWindowRoute.bind(this),
+        // 显示主窗口
+        showMainWindow: this.showMainWindow.bind(this),
+        // 显示设置窗口
+        showSettingWindow: this.showSettingWindow.bind(this),
+        // 重启应用
+        restart: this.restart.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取应用信息
+   * @returns {Promise<XoApp.Info>}
+   */
+  getInfo = async () => {
+    const data = await BridgeUtil.invoke(AppChannels.getInfo);
+    return data ?? {};
+  };
+  /**
+   * 获取应用目录
+   * @returns {Promise<XoApp.Paths>}
+   */
+  getPaths = async () => {
+    const data = await BridgeUtil.invoke(AppChannels.getPaths);
+    return data ?? {
+      userData: "",
+      sessionData: "",
+      logs: "",
+      crashDumps: "",
+      temp: "",
+      updaterCacheDir: ""
+    };
+  };
+  /**
+   * 获取通用设置
+   * @returns {Promise<XoApp.GeneralSettings>}
+   */
+  getGeneralSettings = async () => {
+    const settings = await BridgeUtil.invoke(AppChannels.getGeneralSettings);
+    return settings ?? {
+      opacity: 1,
+      windowMaterial: "none",
+      shortcuts: {},
+      logLevel: "info",
+      launchOnStartup: false,
+      appLaunchMode: "window",
+      windowCloseBehavior: "minimize"
+    };
+  };
+  /**
+   * 获取 APP 透明度
+   * @returns {Promise<number>}
+   */
+  getOpacity = async () => {
+    const opacity = await BridgeUtil.invoke(AppChannels.getOpacity);
+    return opacity ?? 1;
+  };
+  /**
+   * 设置 APP 透明度
+   * @param {number} opacity APP 透明度
+   * @returns {Promise<void>}
+   */
+  setOpacity = async (opacity) => {
+    await BridgeUtil.invoke(AppChannels.setOpacity, opacity);
+  };
+  /**
+   * 获取快捷窗口材质
+   * @returns {Promise<XoApp.WindowMaterial | undefined>}
+   */
+  getWindowMaterial = async () => {
+    return await BridgeUtil.invoke(AppChannels.getWindowMaterial);
+  };
+  /**
+   * 设置快捷窗口材质
+   * @param {XoApp.WindowMaterial} windowMaterial 窗口材质
+   * @returns {Promise<void>}
+   */
+  setWindowMaterial = async (windowMaterial) => {
+    await BridgeUtil.invoke(AppChannels.setWindowMaterial, windowMaterial);
+  };
+  /**
+   * 获取应用启动模式
+   * @returns {Promise<XoApp.AppLaunchMode>}
+   */
+  getAppLaunchMode = async () => {
+    const appLaunchMode = await BridgeUtil.invoke(AppChannels.getAppLaunchMode);
+    return appLaunchMode ?? "window";
+  };
+  /**
+   * 设置应用启动模式
+   * @param {XoApp.AppLaunchMode} appLaunchMode 应用启动模式
+   * @returns {Promise<void>}
+   */
+  setAppLaunchMode = async (appLaunchMode) => {
+    await BridgeUtil.invoke(AppChannels.setAppLaunchMode, appLaunchMode);
+  };
+  /**
+   * 获取是否开机启动
+   * @returns {Promise<boolean>}
+   */
+  getLaunchOnStartup = async () => {
+    const launchOnStartup = await BridgeUtil.invoke(AppChannels.getLaunchOnStartup);
+    return launchOnStartup ?? false;
+  };
+  /**
+   * 设置是否开机启动
+   * @param {boolean} launchOnStartup 是否开机启动
+   * @returns {Promise<void>}
+   */
+  setLaunchOnStartup = async (launchOnStartup) => {
+    await BridgeUtil.invoke(AppChannels.setLaunchOnStartup, launchOnStartup);
+  };
+  /**
+   * 获取关闭窗口行为
+   * @returns {Promise<XoApp.WindowCloseBehavior>}
+   */
+  getWindowCloseBehavior = async () => {
+    const windowCloseBehavior = await BridgeUtil.invoke(AppChannels.getWindowCloseBehavior);
+    return windowCloseBehavior ?? "minimize";
+  };
+  /**
+   * 设置关闭窗口行为
+   * @param {XoApp.WindowCloseBehavior} windowCloseBehavior 关闭窗口行为
+   * @returns {Promise<void>}
+   */
+  setWindowCloseBehavior = async (windowCloseBehavior) => {
+    await BridgeUtil.invoke(AppChannels.setWindowCloseBehavior, windowCloseBehavior);
+  };
+  /**
+   * 获取日志等级
+   * @returns {Promise<XoLogger.Level>}
+   */
+  getLogLevel = async () => {
+    const logLevel = await BridgeUtil.invoke(AppChannels.getLogLevel);
+    return logLevel ?? "info";
+  };
+  /**
+   * 设置日志等级
+   * @param {XoLogger.Level} logLevel 日志等级
+   * @returns {Promise<void>}
+   */
+  setLogLevel = async (logLevel) => {
+    await BridgeUtil.invoke(AppChannels.setLogLevel, logLevel ?? "info");
+  };
+  /**
+   * 获取快捷键配置
+   * @returns {Promise<XoShortcut.KeyMap>}
+   */
+  getShortcuts = async () => {
+    const shortcuts = await BridgeUtil.invoke(AppChannels.getShortcuts);
+    return shortcuts ?? {};
+  };
+  /**
+   * 设置快捷键配置
+   * @param {XoShortcut.KeyMap} shortcuts 快捷键配置
+   * @returns {Promise<void>}
+   */
+  setShortcuts = async (shortcuts) => {
+    await BridgeUtil.invoke(AppChannels.setShortcuts, shortcuts);
+  };
+  /**
+   * 设置单个快捷键配置
+   * @param {XoShortcut.Key} shortcut 快捷键配置
+   * @returns {Promise<void>}
+   */
+  setShortcut = async (shortcut) => {
+    await BridgeUtil.invoke(AppChannels.setShortcut, shortcut);
+  };
+  /**
+   * 删除快捷键配置
+   * @param {XoShortcut.ID} id 快捷键 ID
+   * @returns {Promise<void>}
+   */
+  deleteShortcut = async (id) => {
+    await BridgeUtil.invoke(AppChannels.deleteShortcut, id);
+  };
+  /** 重定向指定窗口路由 */
+  redirectWindowRoute = async (request) => {
+    const result = await BridgeUtil.invoke(AppChannels.redirectWindowRoute, request);
+    return result ?? false;
+  };
+  /** 重定向主窗口路由 */
+  redirectMainWindowRoute = async (request) => {
+    const result = await BridgeUtil.invoke(AppChannels.redirectMainWindowRoute, request);
+    return result ?? false;
+  };
+  /** 重定向设置窗口路由 */
+  redirectSettingWindowRoute = async (request) => {
+    const result = await BridgeUtil.invoke(AppChannels.redirectSettingWindowRoute, request);
+    return result ?? false;
+  };
+  /**
+   * 显示主窗口
+   * @param {XoWindow.RouteRedirectRequestWithoutWindow} request 路由重定向请求
+   * @returns {Promise<void>}
+   */
+  showMainWindow = async (request) => {
+    await BridgeUtil.invoke(AppChannels.showMainWindow, request);
+  };
+  /**
+   * 显示设置窗口
+   * @param {XoWindow.RouteRedirectRequestWithoutWindow} request 路由重定向请求
+   * @returns {Promise<void>}
+   */
+  showSettingWindow = async (request) => {
+    await BridgeUtil.invoke(AppChannels.showSettingWindow, request);
+  };
+  /**
+   * 重启应用
+   * @returns {Promise<void>}
+   */
+  restart = async () => {
+    await BridgeUtil.invoke(AppChannels.restart);
+  };
+};
+
+// src/preload/bridges/auth/auth-bridge.ts
+var AuthBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * @returns {{auth: XoBridgeApi.Map['auth']}}
+   */
+  apiMap() {
+    return {
+      auth: {
+        // 获取认证状态
+        getState: this.getState.bind(this),
+        // 登录
+        login: this.login.bind(this),
+        // 退出登录
+        logout: this.logout.bind(this),
+        // 监听认证状态
+        onState: this.onState.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取认证状态
+   * @returns {Promise<XoAuth.State>}
+   */
+  getState = async () => {
+    return await BridgeUtil.invoke(AuthChannels.getState) ?? { status: "unauthenticated" };
+  };
+  /**
+   * 登录
+   * @param {XoAuth.LoginRequest} request 登录请求
+   * @returns {Promise<XoAuth.State>}
+   */
+  login = async (request) => {
+    return await BridgeUtil.invoke(AuthChannels.login, request) ?? { status: "unauthenticated" };
+  };
+  /**
+   * 退出登录
+   * @returns {Promise<XoAuth.State>}
+   */
+  logout = async () => {
+    return await BridgeUtil.invoke(AuthChannels.logout) ?? { status: "unauthenticated" };
+  };
+  /**
+   * 监听认证状态
+   * @param {XoAuth.StateListener} listener 状态监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(AuthChannels.onState, listener);
+  };
+};
+
+// src/preload/bridges/clipboard/clipboard-bridge.ts
+var ClipboardBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.clipboard}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      clipboard: {
+        // 读取文本
+        readText: this.readText.bind(this),
+        // 写入文本
+        writeText: this.writeText.bind(this),
+        // 写入图片
+        writeImage: this.writeImage.bind(this),
+        // 清空剪切板
+        clear: this.clear.bind(this)
+      }
+    };
+  }
+  /**
+   * 读取文本
+   * @returns {Promise<string>}
+   */
+  readText = async () => {
+    const text = await BridgeUtil.invoke(ClipboardChannels.readText);
+    return text ?? "";
+  };
+  /**
+   * 写入文本
+   * @param {string} text 文本
+   * @returns {Promise<void>}
+   */
+  writeText = async (text) => {
+    await BridgeUtil.invoke(ClipboardChannels.writeText, text);
+  };
+  /**
+   * 写入图片
+   * @param {string} dataURL 图片 DataURL
+   * @returns {Promise<void>}
+   */
+  writeImage = async (dataURL) => {
+    await BridgeUtil.invoke(ClipboardChannels.writeImage, dataURL);
+  };
+  /**
+   * 清空剪切板
+   * @returns {Promise<void>}
+   */
+  clear = async () => {
+    await BridgeUtil.invoke(ClipboardChannels.clear);
+  };
+};
+
+// src/preload/bridges/context-menu/context-menu-bridge.ts
+var ContextMenuBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.contextMenu}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      contextMenu: {
+        // 监听上下文菜单请求
+        onRequested: this.onRequested.bind(this),
+        // 执行菜单命令
+        executeCommand: this.executeCommand.bind(this)
+      }
+    };
+  }
+  /**
+   * 监听上下文菜单请求
+   * @param {XoMenu.ContextMenuRequestedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onRequested(listener) {
+    return BridgeUtil.on(ContextMenuChannels.onRequested, listener);
+  }
+  /**
+   * 执行菜单命令
+   * @param {XoMenu.ExecuteCommandRequest} request 请求
+   * @returns {Promise<boolean>}
+   */
+  executeCommand = async (request) => {
+    const success = await BridgeUtil.invoke(ContextMenuChannels.executeCommand, request);
+    return success ?? false;
+  };
+};
+
+// src/preload/bridges/dialog/dialog-bridge.ts
+var DialogBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.dialog}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      dialog: {
+        // 打开文件选择框
+        openFile: this.openFile.bind(this),
+        // 打开目录选择框
+        openDir: this.openDir.bind(this),
+        // 打开文件保存框
+        saveFile: this.saveFile.bind(this)
+      }
+    };
+  }
+  /**
+   * 打开文件选择框
+   * @returns {Promise<XoDialog.OpenResult>}
+   */
+  openFile = async () => {
+    const openResult = await BridgeUtil.invoke(DialogChannels.openFile);
+    return openResult ?? { canceled: true, filePaths: [] };
+  };
+  /**
+   * 打开目录选择框
+   * @returns {Promise<XoDialog.OpenResult>}
+   */
+  openDir = async () => {
+    const openResult = await BridgeUtil.invoke(DialogChannels.openDir);
+    return openResult ?? { canceled: true, filePaths: [] };
+  };
+  /**
+   * 打开文件保存框
+   * @returns {Promise<XoDialog.SaveResult>}
+   */
+  saveFile = async () => {
+    const saveResult = await BridgeUtil.invoke(DialogChannels.saveFile);
+    return saveResult ?? { canceled: true, filePath: null };
+  };
+};
+
+// src/preload/bridges/file/file-bridge.ts
+var FileBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.file}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      file: {
+        // 读取文本文件
+        readText: this.readText.bind(this),
+        // 写入文本文件
+        writeText: this.writeText.bind(this),
+        // 文件是否存在
+        exists: this.exists.bind(this)
+      }
+    };
+  }
+  /**
+   * 读取文本文件
+   * @param {string} path 文件路径
+   * @returns {Promise<string>}
+   */
+  readText = async (path) => {
+    const text = await BridgeUtil.invoke(FileChannels.readText, path);
+    return text ?? "";
+  };
+  /**
+   * 写入文本文件
+   * @param {string} path    文件路径
+   * @param {string} content 内容
+   * @returns {Promise<boolean>}
+   */
+  writeText = async (path, content) => {
+    const request = { path, content };
+    const success = await BridgeUtil.invoke(FileChannels.writeText, request);
+    return success ?? false;
+  };
+  /**
+   * 文件是否存在
+   * @param {string} path 文件路径
+   * @returns {Promise<boolean>}
+   */
+  exists = async (path) => {
+    const exists = await BridgeUtil.invoke(FileChannels.exists, path);
+    return exists ?? false;
+  };
+};
+
+// src/preload/bridges/ipc/ipc-bridge.ts
+var IpcBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.ipc}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      ipc: {
+        // 调用主进程方法
+        invoke: this.invoke.bind(this),
+        // 给主进程发送消息
+        send: this.send.bind(this),
+        // 监听主进程消息
+        on: this.on.bind(this),
+        // 单次监听主进程消息
+        once: this.once.bind(this)
+      }
+    };
+  }
+  /**
+   * 调用主进程方法（内置）
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any}           request 参数
+   * @returns {Promise<XoIpc.Result>}
+   */
+  invoke = async (channel, request) => {
+    return await BridgeUtil.invokeResult(channel, request);
+  };
+  /**
+   * 给主进程发送消息（内置）
+   * @param {XoIpc.Channel} channel 通道
+   * @param {any}           request 参数
+   */
+  send = (channel, request) => {
+    BridgeUtil.send(channel, request);
+  };
+  /**
+   * 监听主进程消息（内置）
+   * <p>支持主动解除监听</p>
+   * <p>const off = window.xion.ipc.on(channel, listener); off()</p>
+   * @param {XoIpc.Channel}  channel  通道
+   * @param {XoIpc.Listener} listener 监听器
+   * @returns {() => void}
+   */
+  on = (channel, listener) => {
+    return BridgeUtil.on(channel, listener);
+  };
+  /**
+   * 单次监听主进程消息（内置）
+   * @param {XoIpc.Channel}  channel  通道
+   * @param {XoIpc.Listener} listener 监听器
+   */
+  once = (channel, listener) => {
+    BridgeUtil.once(channel, listener);
+  };
+};
+
+// src/preload/bridges/log/log-bridge.ts
+var LogBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.log}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      log: {
+        debug: this.debug.bind(this),
+        info: this.info.bind(this),
+        warn: this.warn.bind(this),
+        error: this.error.bind(this)
+      }
+    };
+  }
+  /**
+   * 写入 debug 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  debug = async (message, ...data) => {
+    await this.write(LogChannels.debug, message, data);
+  };
+  /**
+   * 写入 info 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  info = async (message, ...data) => {
+    await this.write(LogChannels.info, message, data);
+  };
+  /**
+   * 写入 warn 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  warn = async (message, ...data) => {
+    await this.write(LogChannels.warn, message, data);
+  };
+  /**
+   * 写入 error 日志
+   * @param message 日志消息
+   * @param data    附加数据
+   * @returns {Promise<void>}
+   */
+  error = async (message, ...data) => {
+    await this.write(LogChannels.error, message, data);
+  };
+  /**
+   * 写入日志
+   * @param {XoIpc.Channel} channel 日志通道
+   * @param {string}        message 日志消息
+   * @param {unknown[]}     data    附加数据
+   * @returns {Promise<void>}
+   * @private
+   */
+  async write(channel, message, data) {
+    try {
+      const request = LogUtil.normalizeRequest(message, data);
+      await BridgeUtil.invoke(channel, request);
+    } catch {
+    }
+  }
+};
+
+// src/preload/bridges/remote-service/remote-service-bridge.ts
+var RemoteServiceBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.remoteService}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      remoteService: {
+        // 获取远程服务状态
+        getState: this.getState.bind(this),
+        // 获取远程服务设置
+        getSettings: this.getSettings.bind(this),
+        // 设置远程服务用户设置
+        setSettings: this.setSettings.bind(this),
+        // 重置远程服务用户设置
+        resetSettings: this.resetSettings.bind(this),
+        // 请求远程服务 API
+        request: this.request.bind(this),
+        // 监听远程服务状态
+        onState: this.onState.bind(this),
+        // 监听远程服务设置
+        onSettings: this.onSettings.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取远程服务状态
+   * @returns {Promise<XoRemoteService.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(RemoteServiceChannels.getState);
+    return state ?? {
+      status: "idle",
+      reconnectCount: 0
+    };
+  };
+  /**
+   * 获取远程服务设置
+   * @returns {Promise<XoRemoteService.EffectiveSettings>}
+   */
+  getSettings = async () => {
+    const settings = await BridgeUtil.invoke(RemoteServiceChannels.getSettings);
+    return settings;
+  };
+  /**
+   * 设置远程服务用户设置
+   * @param {XoRemoteService.UserSettings} settings 远程服务用户设置
+   * @returns {Promise<void>}
+   */
+  setSettings = async (settings) => {
+    await BridgeUtil.invoke(RemoteServiceChannels.setSettings, settings);
+  };
+  /**
+   * 重置远程服务用户设置
+   * @returns {Promise<void>}
+   */
+  resetSettings = async () => {
+    await BridgeUtil.invoke(RemoteServiceChannels.resetSettings);
+  };
+  /**
+   * 请求远程服务 API
+   * @template T 响应数据类型
+   * @param {XoRemoteService.Request} request 请求参数
+   * @returns {Promise<XoRemoteService.Response<T>>}
+   */
+  request = async (request) => {
+    const response = await BridgeUtil.invoke(RemoteServiceChannels.request, request);
+    return response;
+  };
+  /**
+   * 监听远程服务状态
+   * @param {XoRemoteService.StateListener} listener 监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(RemoteServiceChannels.onState, listener);
+  };
+  /**
+   * 监听远程服务设置
+   * @param {XoRemoteService.SettingsListener} listener 监听器
+   * @returns {() => void}
+   */
+  onSettings = (listener) => {
+    return BridgeUtil.on(RemoteServiceChannels.onSettings, listener);
+  };
+};
+
+// src/preload/bridges/shell/shell-bridge.ts
+var ShellBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.shell}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      shell: {
+        // 使用系统默认程序打开路径
+        openPath: this.openPath.bind(this),
+        // 在文件管理器中显示路径
+        showItemInFolder: this.showItemInFolder.bind(this)
+      }
+    };
+  }
+  /**
+   * 使用系统默认程序打开路径
+   * @param {string} path 路径
+   * @returns {Promise<void>}
+   */
+  openPath = async (path) => {
+    await BridgeUtil.invoke(ShellChannels.openPath, path);
+  };
+  /**
+   * 在文件管理器中显示路径
+   * @param {string} path 路径
+   * @returns {Promise<void>}
+   */
+  showItemInFolder = async (path) => {
+    await BridgeUtil.invoke(ShellChannels.showItemInFolder, path);
+  };
+};
+
+// src/preload/bridges/theme/theme-bridge.ts
+var ThemeBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.theme}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      theme: {
+        // 获取主题状态
+        getState: this.getState.bind(this),
+        // 设置主题来源
+        setSource: this.setSource.bind(this),
+        // 监听主题更新
+        onUpdated: this.onUpdated.bind(this)
+      }
+    };
+  }
+  /**
+   * 获取主题状态
+   * @returns {Promise<XoTheme.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(ThemeChannels.getState);
+    return state ?? {
+      themeSource: "system",
+      shouldUseDarkColors: false,
+      titleBarOverlayEnabled: false,
+      titleBarOverlay: {},
+      titleBarOverlayBackground: void 0
+    };
+  };
+  /**
+   * 设置主题来源
+   * @param {XoTheme.Source} themeSource 主题来源
+   * @returns {Promise<void>}
+   */
+  setSource = async (themeSource) => {
+    await BridgeUtil.invoke(ThemeChannels.setSource, themeSource);
+  };
+  /**
+   * 监听主题更新
+   * @param {XoTheme.UpdatedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onUpdated = (listener) => {
+    return BridgeUtil.on(ThemeChannels.onUpdate, listener);
+  };
+};
+
+// src/preload/bridges/updater/updater-bridge.ts
+var UpdaterBridge = class extends BridgeAbstract {
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.updater}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      updater: {
+        // 检查更新
+        checkForUpdates: this.checkForUpdates.bind(this),
+        // 下载更新
+        downloadUpdate: this.downloadUpdate.bind(this),
+        // 取消下载
+        cancelDownload: this.cancelDownload.bind(this),
+        // 退出并安装更新
+        quitAndInstall: this.quitAndInstall.bind(this),
+        // 获取更新器状态
+        getState: this.getState.bind(this),
+        // 获取更新器设置
+        getSettings: this.getSettings.bind(this),
+        // 设置更新器用户设置
+        setSettings: this.setSettings.bind(this),
+        // 重置更新器用户设置
+        resetSettings: this.resetSettings.bind(this),
+        // 监听更新器状态
+        onState: this.onState.bind(this),
+        // 监听更新器设置
+        onSettings: this.onSettings.bind(this)
+      }
+    };
+  }
+  /**
+   * 检查更新
+   * @returns {Promise<void>}
+   */
+  checkForUpdates = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.checkForUpdates);
+  };
+  /**
+   * 下载更新
+   * @returns {Promise<void>}
+   */
+  downloadUpdate = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.downloadUpdate);
+  };
+  /**
+   * 取消下载
+   * @returns {Promise<boolean>}
+   */
+  cancelDownload = async () => {
+    const cancelled = await BridgeUtil.invoke(UpdaterChannels.cancelDownload);
+    return cancelled ?? false;
+  };
+  /**
+   * 退出并安装更新
+   * @returns {Promise<void>}
+   */
+  quitAndInstall = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.quitAndInstall);
+  };
+  /**
+   * 获取更新器状态
+   * @returns {Promise<XoUpdater.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(UpdaterChannels.getState);
+    return state ?? {
+      status: "idle",
+      downloadCancellationCount: 0,
+      disabledUntilRestart: false
+    };
+  };
+  /**
+   * 获取更新器设置
+   * @returns {Promise<XoUpdater.EffectiveSettings>}
+   */
+  getSettings = async () => {
+    const settings = await BridgeUtil.invoke(UpdaterChannels.getSettings);
+    return settings;
+  };
+  /**
+   * 设置更新器用户设置
+   * @param {XoUpdater.UserSettings} settings 更新器用户设置
+   */
+  setSettings = async (settings) => {
+    await BridgeUtil.invoke(UpdaterChannels.setSettings, settings);
+  };
+  /**
+   * 重置更新器用户设置
+   */
+  resetSettings = async () => {
+    await BridgeUtil.invoke(UpdaterChannels.resetSettings);
+  };
+  /**
+   * 监听更新器状态
+   * @param {XoUpdater.UpdatedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(UpdaterChannels.onState, listener);
+  };
+  /**
+   * 监听更新器设置
+   * @param {XoUpdater.SettingsUpdatedListener} listener 监听器
+   * @returns {() => void}
+   */
+  onSettings = (listener) => {
+    return BridgeUtil.on(UpdaterChannels.onSettings, listener);
+  };
+};
+
+// src/preload/bridges/window/internal/route-redirect-buffer.ts
+var RouteRedirectBuffer = class {
+  /** Renderer 是否已完成初始化 */
+  rendererReady = false;
+  /** Renderer 路由重定向监听器 */
+  listener;
+  /** 等待分发的路由重定向请求 */
+  pendingRequests = [];
+  /**
+   * 接收路由重定向请求
+   * @param {XoWindow.RouteRedirectRequest} request 路由重定向请求
+   * @returns {void}
+   */
+  receive(request) {
+    if (!this.rendererReady || !this.listener) {
+      this.pendingRequests.push(request);
+      return;
+    }
+    this.listener(request);
+  }
+  /**
+   * 设置 Renderer 路由重定向监听器
+   * @param {XoWindow.RouteRedirectListener} listener 路由重定向监听器
+   * @returns {() => void}
+   */
+  setListener(listener) {
+    this.listener = listener;
+    this.flush();
+    return () => {
+      if (this.listener === listener) {
+        this.listener = void 0;
+      }
+    };
+  }
+  /**
+   * 标记 Renderer 已完成初始化
+   * @returns {void}
+   */
+  setReady() {
+    this.rendererReady = true;
+    this.flush();
+  }
+  /**
+   * 分发等待中的路由重定向请求
+   * @returns {void}
+   * @private
+   */
+  flush() {
+    const listener = this.listener;
+    if (!this.rendererReady || !listener) {
+      return;
+    }
+    for (const request of this.pendingRequests.splice(0)) {
+      listener(request);
+    }
+  }
+};
+
+// src/preload/bridges/window/window-bridge.ts
+var WindowBridge = class extends BridgeAbstract {
+  /** 路由重定向请求缓冲器 */
+  routeRedirectBuffer = new RouteRedirectBuffer();
+  /**
+   * 构造函数
+   */
+  constructor() {
+    super();
+    BridgeUtil.on(WindowChannels.onRouteRedirect, (request) => this.routeRedirectBuffer.receive(request));
+  }
+  /**
+   * 接口映射
+   * <p>渲染进程声明文件 {@link XoBridgeApi.Map.window}</p>
+   * @returns {XoBridge.ApiMap}
+   */
+  apiMap() {
+    return {
+      window: {
+        // 通知主进程渲染进程首屏渲染完成
+        ready: this.ready.bind(this),
+        // 是否等待 Renderer 渲染完成后再显示窗口
+        shouldShowAfterRendererReady: this.shouldShowAfterRendererReady.bind(this),
+        // 获取窗口状态
+        getState: this.getState.bind(this),
+        // 获取当前已打开窗口标识
+        getOpenedWindowIdentities: this.getOpenedWindowIdentities.bind(this),
+        // 最小化窗口
+        minimize: this.minimize.bind(this),
+        // 最大化窗口
+        maximize: this.maximize.bind(this),
+        // 是否已最大化
+        isMaximized: this.isMaximized.bind(this),
+        // 取消最大化窗口
+        unmaximize: this.unmaximize.bind(this),
+        // 全屏窗口
+        fullScreen: this.fullScreen.bind(this),
+        // 退出全屏窗口
+        exitFullScreen: this.exitFullScreen.bind(this),
+        // 重新加载窗口
+        reload: this.reload.bind(this),
+        // 居中窗口
+        center: this.center.bind(this),
+        // 隐藏窗口
+        hide: this.hide.bind(this),
+        // 还原窗口
+        restore: this.restore.bind(this),
+        // 切换窗口置顶
+        toggleAlwaysOnTop: this.toggleAlwaysOnTop.bind(this),
+        // 切换侧边栏折叠
+        toggleSidebarFold: this.toggleSidebarFold.bind(this),
+        // 关闭窗口
+        close: this.close.bind(this),
+        // 监听窗口状态
+        onState: this.onState.bind(this),
+        // 监听路由重定向
+        onRouteRedirect: this.onRouteRedirect.bind(this)
+      }
+    };
+  }
+  /**
+   * 通知主进程渲染进程首屏渲染完成
+   * @returns {Promise<void>}
+   */
+  ready = async () => {
+    this.routeRedirectBuffer.setReady();
+    await BridgeUtil.invoke(WindowChannels.ready);
+  };
+  /**
+   * 是否等待 Renderer 渲染完成后再显示窗口
+   * @returns {Promise<boolean>}
+   */
+  shouldShowAfterRendererReady = async () => {
+    const enabled = await BridgeUtil.invoke(WindowChannels.shouldShowAfterRendererReady);
+    return enabled ?? true;
+  };
+  /**
+   * 获取窗口状态
+   * @returns {Promise<XoWindow.State>}
+   */
+  getState = async () => {
+    const state = await BridgeUtil.invoke(WindowChannels.getState);
+    return state ?? {
+      isSidebarFolded: false,
+      isAlwaysOnTop: false,
+      isMaximized: false,
+      isFullScreen: false,
+      isMinimized: false,
+      isFullScreenable: false,
+      isMinimizable: false,
+      isMaximizable: false,
+      isClosable: false
+    };
+  };
+  /**
+   * 获取当前已打开窗口标识
+   * @returns {Promise<XoWindow.Identity[]>}
+   */
+  getOpenedWindowIdentities = async () => {
+    return await BridgeUtil.invoke(WindowChannels.getOpenedWindowIdentities) ?? [];
+  };
+  /**
+   * 最小化窗口
+   * @returns {Promise<void>}
+   */
+  minimize = async () => {
+    await BridgeUtil.invoke(WindowChannels.minimize);
+  };
+  /**
+   * 最大化窗口
+   * @returns {Promise<void>}
+   */
+  maximize = async () => {
+    await BridgeUtil.invoke(WindowChannels.maximize);
+  };
+  /**
+   * 是否已最大化
+   * @returns {Promise<boolean>}
+   */
+  isMaximized = async () => {
+    const maximized = await BridgeUtil.invoke(WindowChannels.isMaximized);
+    return maximized ?? false;
+  };
+  /**
+   * 取消最大化窗口
+   * @returns {Promise<void>}
+   */
+  unmaximize = async () => {
+    await BridgeUtil.invoke(WindowChannels.unmaximize);
+  };
+  /**
+   * 全屏窗口
+   * @returns {Promise<void>}
+   */
+  fullScreen = async () => {
+    await BridgeUtil.invoke(WindowChannels.fullScreen);
+  };
+  /**
+   * 退出全屏窗口
+   * @returns {Promise<void>}
+   */
+  exitFullScreen = async () => {
+    await BridgeUtil.invoke(WindowChannels.exitFullScreen);
+  };
+  /**
+   * 重新加载窗口
+   * @returns {Promise<void>}
+   */
+  reload = async () => {
+    await BridgeUtil.invoke(WindowChannels.reload);
+  };
+  /**
+   * 居中窗口
+   * @returns {Promise<void>}
+   */
+  center = async () => {
+    await BridgeUtil.invoke(WindowChannels.center);
+  };
+  /**
+   * 隐藏窗口
+   * @returns {Promise<void>}
+   */
+  hide = async () => {
+    await BridgeUtil.invoke(WindowChannels.hide);
+  };
+  /**
+   * 还原窗口
+   * @returns {Promise<void>}
+   */
+  restore = async () => {
+    await BridgeUtil.invoke(WindowChannels.restore);
+  };
+  /**
+   * 切换窗口置顶
+   * @returns {Promise<void>}
+   */
+  toggleAlwaysOnTop = async () => {
+    await BridgeUtil.invoke(WindowChannels.toggleAlwaysOnTop);
+  };
+  /**
+   * 切换侧边栏折叠
+   * @returns {Promise<void>}
+   */
+  toggleSidebarFold = async () => {
+    await BridgeUtil.invoke(WindowChannels.toggleSidebarFold);
+  };
+  /**
+   * 关闭窗口
+   * @returns {Promise<void>}
+   */
+  close = async () => {
+    await BridgeUtil.invoke(WindowChannels.close);
+  };
+  /**
+   * 监听窗口状态
+   * @param {XoWindow.StateListener} listener 监听器
+   * @returns {() => void}
+   */
+  onState = (listener) => {
+    return BridgeUtil.on(WindowChannels.onState, listener);
+  };
+  /**
+   * 监听路由重定向
+   * @param {XoWindow.RouteRedirectListener} listener 监听器
+   * @returns {() => void}
+   */
+  onRouteRedirect = (listener) => {
+    return this.routeRedirectBuffer.setListener(listener);
+  };
+};
+
+export {
+  BridgeAbstract,
+  AppBridge,
+  AuthBridge,
+  ClipboardBridge,
+  ContextMenuBridge,
+  DialogBridge,
+  FileBridge,
+  IpcBridge,
+  LogBridge,
+  RemoteServiceBridge,
+  ShellBridge,
+  ThemeBridge,
+  UpdaterBridge,
+  WindowBridge
+};