@e-xi/xion 0.0.6

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

@@ -0,0 +1,1269 @@
+import {
+  MenuCommands
+} from "./chunk-GUOSVDXA.js";
+import {
+  XionName
+} from "./chunk-YLZRRUY7.js";
+import {
+  SettingWindowIdentity
+} from "./chunk-PVWRRUOK.js";
+
+// src/main/menu/menu-items.ts
+import { app, BrowserWindow, clipboard, dialog, session, shell } from "electron";
+import { copyFile, writeFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { fileURLToPath } from "node:url";
+var MenuItems = class _MenuItems {
+  //<editor-fold desc="iconfont 图标">
+  /**
+   * 内置菜单图标
+   * @param {string} name 图标名称
+   * @returns {XoMenu.Icon}
+   */
+  static icon(name) {
+    return {
+      type: "class",
+      value: `xion-font xion-icon-${name}`
+    };
+  }
+  //</editor-fold>
+  //<editor-fold desc="菜单分组">
+  /**
+   * 菜单组
+   * @param {string}          label 菜单组名称
+   * @param {XoMenu.SubMenus} items 菜单项
+   * @returns {XoMenu.Item}
+   */
+  static group(label, items) {
+    return {
+      label,
+      submenu: items
+    };
+  }
+  //</editor-fold>
+  //<editor-fold desc="Electron 内置菜单">
+  /**
+   * 分割线
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static separator(enabled = true) {
+    return {
+      type: "separator",
+      enabled
+    };
+  }
+  /**
+   * 撤销
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static undo(enabled = true) {
+    return {
+      label: "\u64A4\u9500",
+      role: "undo",
+      accelerator: "CmdOrCtrl+Z",
+      rendererIcon: _MenuItems.icon("undo"),
+      enabled
+    };
+  }
+  /**
+   * 重做
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static redo(enabled = true) {
+    return {
+      label: "\u91CD\u505A",
+      role: "redo",
+      accelerator: "CmdOrCtrl+Shift+Z",
+      rendererIcon: _MenuItems.icon("redo"),
+      enabled
+    };
+  }
+  /**
+   * 剪切
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static cut(enabled = true) {
+    return {
+      label: "\u526A\u5207",
+      role: "cut",
+      accelerator: "CmdOrCtrl+X",
+      rendererIcon: _MenuItems.icon("cut"),
+      enabled
+    };
+  }
+  /**
+   * 复制
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static copy(enabled = true) {
+    return {
+      label: "\u590D\u5236",
+      role: "copy",
+      accelerator: "CmdOrCtrl+C",
+      rendererIcon: _MenuItems.icon("copy"),
+      enabled
+    };
+  }
+  /**
+   * 粘贴
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static paste(enabled = true) {
+    return {
+      label: "\u7C98\u8D34",
+      role: "paste",
+      accelerator: "CmdOrCtrl+V",
+      rendererIcon: _MenuItems.icon("paste"),
+      enabled
+    };
+  }
+  /**
+   * 删除
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static del(enabled = true) {
+    return {
+      label: "\u5220\u9664",
+      role: "delete",
+      accelerator: "Delete",
+      rendererIcon: _MenuItems.icon("delete"),
+      enabled
+    };
+  }
+  /**
+   * 全选
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static selectAll(enabled = true) {
+    return {
+      label: "\u5168\u9009",
+      role: "selectAll",
+      accelerator: "CmdOrCtrl+A",
+      rendererIcon: _MenuItems.icon("select-all"),
+      enabled
+    };
+  }
+  /**
+   * 最小化
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static minimize(enabled = true) {
+    return {
+      label: "\u6700\u5C0F\u5316",
+      role: "minimize",
+      accelerator: "CmdOrCtrl+M",
+      rendererIcon: _MenuItems.icon("minimize"),
+      enabled
+    };
+  }
+  /**
+   * 刷新
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static reload(enabled = true) {
+    return {
+      label: "\u5237\u65B0",
+      role: "reload",
+      accelerator: "F5",
+      rendererIcon: _MenuItems.icon("reload"),
+      visible: enabled,
+      enabled
+    };
+  }
+  /**
+   * 强制刷新
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static forceReload(enabled = true) {
+    return {
+      label: "\u5F3A\u5236\u5237\u65B0",
+      role: "forceReload",
+      accelerator: "CmdOrCtrl+F5",
+      rendererIcon: _MenuItems.icon("force-reload"),
+      visible: enabled,
+      enabled
+    };
+  }
+  /**
+   * 切换全屏
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static toggleFullscreen(enabled = true) {
+    const isFullScreen = BrowserWindow.getFocusedWindow()?.isFullScreen();
+    return {
+      label: `${isFullScreen ? "\u9000\u51FA" : ""}\u5168\u5C4F`,
+      role: "togglefullscreen",
+      accelerator: "F11",
+      rendererIcon: _MenuItems.icon(isFullScreen ? "exit-fullscreen" : "fullscreen"),
+      enabled
+    };
+  }
+  /**
+   * 切换开发者工具
+   * @returns {XoMenu.Item}
+   */
+  static toggleDevTools() {
+    const isDevToolsOpened = BrowserWindow.getFocusedWindow()?.webContents?.isDevToolsOpened();
+    return {
+      label: `${isDevToolsOpened ? "\u5173\u95ED" : "\u6253\u5F00"}\u5F00\u53D1\u8005\u5DE5\u5177`,
+      role: "toggleDevTools",
+      accelerator: "F12",
+      rendererIcon: _MenuItems.icon("toggle-dev-tools"),
+      enabled: !app.isPackaged,
+      visible: !app.isPackaged
+    };
+  }
+  /**
+   * 关闭窗口
+   * @param {boolean} enabled 是否启用
+   * @param {string}  label   名称
+   * @returns {XoMenu.Item}
+   */
+  static close(enabled = true, label = "\u5173\u95ED\u7A97\u53E3") {
+    return {
+      label,
+      enabled,
+      role: "close",
+      accelerator: "CmdOrCtrl+W",
+      rendererIcon: _MenuItems.icon("close")
+    };
+  }
+  /**
+   * 关于
+   * @param {boolean} enabled 是否启用
+   * @param {string}  label   名称
+   * @returns {XoMenu.Item}
+   */
+  static about(enabled = true, label = "\u5173\u4E8E") {
+    return {
+      label,
+      enabled,
+      role: "about",
+      accelerator: "F1"
+    };
+  }
+  //</editor-fold>
+  //<editor-fold desc="页面内容菜单">
+  /**
+   * 打开链接
+   * @param {string}  url     链接地址
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static openLink(url, enabled = Boolean(url)) {
+    return {
+      label: "\u6253\u5F00\u94FE\u63A5",
+      visible: Boolean(url),
+      enabled,
+      rendererIcon: _MenuItems.icon("open-link"),
+      command: MenuCommands.linkOpen,
+      payload: null,
+      click: () => {
+        url && void shell.openExternal(url);
+      }
+    };
+  }
+  /**
+   * 复制链接地址
+   * @param {string}  url     链接地址
+   * @param {boolean} enabled 是否启用
+   * @returns {XoMenu.Item}
+   */
+  static copyLink(url, enabled = Boolean(url)) {
+    return {
+      label: "\u590D\u5236\u94FE\u63A5\u5730\u5740",
+      visible: Boolean(url),
+      enabled,
+      rendererIcon: _MenuItems.icon("copy-link"),
+      command: MenuCommands.linkCopy,
+      payload: null,
+      click: () => {
+        url && clipboard.writeText(url);
+      }
+    };
+  }
+  /**
+   * 打开图片
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item}
+   */
+  static openImage(state) {
+    const visible = state.mediaType === "image" || Boolean(state.hasImageContents);
+    const enabled = visible && Boolean(state.srcURL);
+    return {
+      label: "\u6253\u5F00\u56FE\u50CF",
+      visible,
+      enabled,
+      rendererIcon: _MenuItems.icon("open-image"),
+      command: MenuCommands.imageOpen,
+      payload: null,
+      click: async () => {
+        if (!state.srcURL) {
+          return;
+        }
+        if (state.srcURL.startsWith("file://")) {
+          const filePath = fileURLToPath(state.srcURL);
+          await shell.openPath(filePath);
+          return;
+        }
+        await shell.openExternal(state.srcURL);
+      }
+    };
+  }
+  /**
+   * 复制图片
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item}
+   */
+  static copyImage(state) {
+    const visible = state.mediaType === "image" || Boolean(state.hasImageContents);
+    const enabled = visible && state.x !== void 0 && state.y !== void 0;
+    return {
+      label: "\u590D\u5236\u56FE\u50CF",
+      visible,
+      enabled,
+      rendererIcon: _MenuItems.icon("copy-image"),
+      command: MenuCommands.imageCopy,
+      payload: null,
+      click: (_menuItem, win) => {
+        if (win instanceof BrowserWindow && state.x !== void 0 && state.y !== void 0) {
+          win.webContents.copyImageAt(state.x, state.y);
+        }
+      }
+    };
+  }
+  /**
+   * 复制图像链接
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item}
+   */
+  static copyImageLink(state) {
+    const visible = state.mediaType === "image" || Boolean(state.hasImageContents);
+    const enabled = visible && Boolean(state.srcURL);
+    return {
+      label: "\u590D\u5236\u56FE\u50CF\u94FE\u63A5",
+      visible,
+      enabled,
+      rendererIcon: _MenuItems.icon("copy-image-link"),
+      command: MenuCommands.imageCopyLink,
+      payload: null,
+      click: () => {
+        state.srcURL && clipboard.writeText(state.srcURL);
+      }
+    };
+  }
+  /**
+   * 将图像另存为
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item}
+   */
+  static saveImageAs(state) {
+    const visible = state.mediaType === "image" || Boolean(state.hasImageContents);
+    const enabled = visible && Boolean(state.srcURL);
+    return {
+      label: "\u5C06\u56FE\u50CF\u53E6\u5B58\u4E3A",
+      visible,
+      enabled,
+      rendererIcon: _MenuItems.icon("image-save"),
+      command: MenuCommands.imageSaveAs,
+      payload: null,
+      click: async (_menuItem, win) => {
+        if (!state.srcURL) {
+          return;
+        }
+        const options = {
+          defaultPath: _MenuItems.imageFileName(state),
+          filters: [
+            {
+              name: "Images",
+              extensions: ["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"]
+            },
+            {
+              name: "All Files",
+              extensions: ["*"]
+            }
+          ]
+        };
+        const result = win instanceof BrowserWindow ? await dialog.showSaveDialog(win, options) : await dialog.showSaveDialog(options);
+        if (result.canceled || !result.filePath) {
+          return;
+        }
+        if (state.srcURL.startsWith("file://")) {
+          await copyFile(fileURLToPath(state.srcURL), result.filePath);
+          return;
+        }
+        const targetSession = win instanceof BrowserWindow ? win.webContents.session : session.defaultSession;
+        const response = await targetSession.fetch(state.srcURL);
+        if (!response.ok) {
+          return;
+        }
+        const data = Buffer.from(await response.arrayBuffer());
+        await writeFile(result.filePath, data);
+      }
+    };
+  }
+  /**
+   * 获取图片文件名
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {string}
+   */
+  static imageFileName(state) {
+    if (state.suggestedFilename) {
+      return state.suggestedFilename;
+    }
+    if (!state.srcURL) {
+      return "image";
+    }
+    try {
+      const url = new URL(state.srcURL);
+      const name = basename(url.pathname);
+      return name || "image";
+    } catch {
+      return basename(state.srcURL) || "image";
+    }
+  }
+  //</editor-fold>
+  //<editor-fold desc="窗口管理">
+  /**
+   * 显示主窗口
+   * @param {XoAppAbstract} xoApp XionApp
+   * @returns {XoMenu.Item}
+   */
+  static showMainWindow(xoApp) {
+    return {
+      label: `\u6253\u5F00 ${xoApp.getAppConfig()?.eletronAppConfig?.productName ?? XionName}`,
+      click: async () => {
+        await xoApp?.showMainWindow();
+        xoApp?.getTrayManager()?.setFocus();
+      }
+    };
+  }
+  /**
+   * 显示设置窗口
+   * @param {XoAppAbstract} xoApp XionApp
+   * @param {string}        label 名称
+   * @returns {XoMenu.Item}
+   */
+  static showSettingWindow(xoApp, label = "\u6253\u5F00\u8BBE\u7F6E") {
+    return {
+      label,
+      click: () => {
+        void xoApp.showSettingWindow();
+      }
+    };
+  }
+  //</editor-fold>
+  //<editor-fold desc="APP 管理">
+  /**
+   * 检查更新
+   * @param {XoAppAbstract} xoApp   XionApp
+   * @param {string}        label   名称
+   * @param {string}        version 当前版本号
+   * @returns {XoMenu.Item}
+   */
+  static checkForUpdate(xoApp, label = "\u68C0\u67E5\u66F4\u65B0", version) {
+    return {
+      label: `${label}${`v${version ?? app.getVersion()}`.padStart(16)}`,
+      click: () => {
+        void xoApp.getUpdaterManager().checkForUpdates();
+        const updaterSettingsRoute = xoApp.getAppConfig()?.updaterSettingsRoute;
+        if (updaterSettingsRoute) {
+          void this.showSettingWindowWithRoute(xoApp, updaterSettingsRoute);
+          return;
+        }
+        void xoApp.showMainWindow();
+      }
+    };
+  }
+  /**
+   * 打开设置窗口并跳转到指定路由
+   * <p>先确保设置窗口存在，避免首次创建时丢失路由请求。</p>
+   * @param {XoAppAbstract} xoApp XionApp
+   * @param {XoWindow.RouteRedirectRequestWithoutWindow} request 路由重定向请求
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async showSettingWindowWithRoute(xoApp, request) {
+    await xoApp.showSettingWindow();
+    await xoApp.getWindowManager().redirectRoute({
+      ...request,
+      windowIdentity: SettingWindowIdentity
+    });
+  }
+  /**
+   * 退出应用
+   * @param {XoAppAbstract} xoApp XionApp
+   * @param {string}        label 名称
+   * @returns {XoMenu.Item}
+   */
+  static appQuit(xoApp, label = "\u9000\u51FA") {
+    return {
+      label,
+      click: () => xoApp.quit()
+    };
+  }
+  //</editor-fold>
+};
+
+// src/main/menu/menu-manager-abstract.ts
+import { app as app2, BrowserWindow as BrowserWindow2, Menu } from "electron";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var MenuManagerAbstract = class {
+  //<editor-fold desc="属性">
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   */
+  xoApp;
+  /**
+   * 上下文菜单缓存过期时间
+   * @type {number}
+   * @protected
+   */
+  contextMenuTTL = 3e4;
+  /**
+   * 上下文菜单请求序号
+   * @type {number}
+   * @private
+   */
+  contextMenuSeq = 0;
+  /**
+   * 上下文菜单缓存
+   * @type {Map<string, XoMenu.ContextMenuRecord>}
+   * @private
+   */
+  contextMenuRecords = /* @__PURE__ */ new Map();
+  /**
+   * 渲染进程图片地址缓存
+   * @type {Map<string, string>}
+   * @private
+   */
+  rendererImageUrlCache = /* @__PURE__ */ new Map();
+  /**
+   * 菜单命令处理器
+   * @type {Map<XoMenu.Command, XoMenu.CommandHandler>}
+   * @private
+   */
+  commandHandlers = /* @__PURE__ */ new Map();
+  //</editor-fold>
+  //<editor-fold desc="构造函数">
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+    this.registerCommands();
+  }
+  //</editor-fold>
+  //<editor-fold desc="安装应用菜单">
+  /**
+   * 安装应用菜单
+   */
+  installAppMenu() {
+    Menu.setApplicationMenu(this.getApplicationMenu());
+  }
+  //</editor-fold>
+  //<editor-fold desc="获取菜单">
+  /**
+   * 获取应用菜单
+   * @returns {Electron.Menu}
+   */
+  getApplicationMenu() {
+    return this.buildMenu(this.applicationMenuItems());
+  }
+  /**
+   * 获取托盘菜单
+   * @returns {Electron.Menu}
+   */
+  getTrayMenu() {
+    return this.buildMenu(this.trayMenuItems());
+  }
+  /**
+   * 按上下文获取菜单
+   * @param {Electron.ContextMenuParams} params 上下文菜单参数
+   * @returns {Electron.Menu}
+   */
+  getContextMenu(params) {
+    const type = this.contextType(params);
+    const state = this.contextState(params);
+    return this.buildMenu(this.contextMenuItems(type, state));
+  }
+  //</editor-fold>
+  //<editor-fold desc="菜单弹出/解析">
+  /**
+   * 弹出上下文菜单（主进程中）
+   * @param {Electron.ContextMenuParams} params 上下文菜单参数
+   * @param {Electron.BrowserWindow}     window 生效窗口
+   */
+  popupContextMenu(params, window) {
+    window && this.getContextMenu(params).popup({ window });
+  }
+  /**
+   * 解析上下文菜单（渲染进程）
+   * @param {Electron.ContextMenuParams} params 上下文菜单参数
+   * @param {Electron.BrowserWindow}     window 生效窗口
+   * @returns {XoMenu.ContextMenuRequest}
+   */
+  resolveContextMenu(params, window) {
+    const type = this.contextType(params);
+    const state = this.contextState(params);
+    const requestId = this.nextContextMenuRequestId();
+    const items = this.contextMenuItems(type, state);
+    const rendererItems = this.toRendererItems(items);
+    const timer = setTimeout(() => {
+      this.deleteContextMenuRecord(requestId);
+    }, this.contextMenuTTL);
+    this.contextMenuRecords.set(requestId, {
+      requestId,
+      window,
+      params,
+      state,
+      timer
+    });
+    return {
+      requestId,
+      x: params.x,
+      y: params.y,
+      items: rendererItems
+    };
+  }
+  /**
+   * 生成上下文菜单请求 ID
+   * @returns {string}
+   * @protected
+   */
+  nextContextMenuRequestId() {
+    this.contextMenuSeq += 1;
+    return `context-menu-${Date.now()}-${this.contextMenuSeq}`;
+  }
+  /**
+   * 转换为渲染进程菜单项
+   * @param {XoMenu.Item[]} items 菜单项
+   * @returns {XoMenu.RendererItem[]}
+   * @protected
+   */
+  toRendererItems(items) {
+    const commandNames = this.builtInRoleCommands();
+    return items.filter((item) => item.visible !== false).map((item, index) => {
+      const submenu = Array.isArray(item.submenu) ? this.toRendererItems(item.submenu) : [];
+      const type = item.type === "separator" ? item.type : submenu.length > 0 ? "submenu" : item.type ?? "normal";
+      return {
+        id: item.id ?? `${item.command ?? item.role ?? item.label ?? "item"}:${index}`,
+        label: item.label ?? "",
+        type,
+        enabled: item.enabled !== false,
+        visible: item.visible !== false,
+        checked: item.checked === true,
+        accelerator: this.rendererAccelerator(item.accelerator),
+        icon: this.rendererIcon(item.rendererIcon),
+        command: item.command ?? (item.role ? commandNames[item.role] ?? null : null),
+        payload: item.payload ?? null,
+        submenu
+      };
+    });
+  }
+  /**
+   * 内置 electron 菜单 role 与命令名的映射
+   * @returns {XoMenu.RoleCommandMap}
+   * @protected
+   */
+  builtInRoleCommands() {
+    return {
+      undo: MenuCommands.editUndo,
+      redo: MenuCommands.editRedo,
+      cut: MenuCommands.editCut,
+      copy: MenuCommands.editCopy,
+      paste: MenuCommands.editPaste,
+      delete: MenuCommands.editDelete,
+      selectAll: MenuCommands.editSelectAll,
+      reload: MenuCommands.windowReload,
+      forceReload: MenuCommands.windowForceReload,
+      minimize: MenuCommands.windowMinimize,
+      togglefullscreen: MenuCommands.windowToggleFullscreen,
+      close: MenuCommands.windowClose,
+      toggleDevTools: MenuCommands.windowToggleDevTools
+    };
+  }
+  /**
+   * 转换渲染进程快捷键文本
+   * @param {Electron.Accelerator | undefined} accelerator Electron 快捷键
+   * @returns {string | null}
+   * @protected
+   */
+  rendererAccelerator(accelerator) {
+    if (typeof accelerator !== "string") {
+      return null;
+    }
+    return accelerator.split("+").map((key) => this.rendererAcceleratorKey(key)).join("+");
+  }
+  /**
+   * 转换渲染进程快捷键按键文本
+   * @param {string} key 按键
+   * @returns {string}
+   * @protected
+   */
+  rendererAcceleratorKey(key) {
+    const isMac = process.platform === "darwin";
+    const modifiers = {
+      command: "Cmd",
+      cmd: "Cmd",
+      control: "Ctrl",
+      ctrl: "Ctrl",
+      commandorcontrol: isMac ? "Cmd" : "Ctrl",
+      cmdorctrl: isMac ? "Cmd" : "Ctrl",
+      alt: "Alt",
+      option: isMac ? "Option" : "Alt",
+      altgr: "AltGr",
+      shift: "Shift",
+      super: isMac ? "Cmd" : "Win",
+      meta: isMac ? "Cmd" : "Win"
+    };
+    return modifiers[key.toLowerCase()] ?? key;
+  }
+  /**
+   * 转换渲染进程菜单图标
+   * @param {XoMenu.Icon | undefined} icon 菜单图标
+   * @returns {XoMenu.Icon | null}
+   * @protected
+   */
+  rendererIcon(icon) {
+    if (!icon || !icon.value) {
+      return null;
+    }
+    if (icon.type === "class") {
+      return icon;
+    }
+    if (icon.type === "image") {
+      return {
+        ...icon,
+        value: this.rendererImageUrl(icon.value)
+      };
+    }
+    return null;
+  }
+  /**
+   * 转换渲染进程图片地址
+   * @param {string} value 图片地址或本地路径
+   * @returns {string}
+   * @protected
+   */
+  rendererImageUrl(value) {
+    const file = this.localImageFile(value);
+    if (!file) {
+      return value;
+    }
+    const cached = this.rendererImageUrlCache.get(file);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const url = `data:${this.imageMimeType(file)};base64,${readFileSync(file).toString("base64")}`;
+      this.rendererImageUrlCache.set(file, url);
+      return url;
+    } catch (e) {
+      this.xoApp.appLog.warn("\u83DC\u5355\u56FE\u6807\u8BFB\u53D6\u5931\u8D25", { file, error: e });
+      return value;
+    }
+  }
+  /**
+   * 获取本地图片路径
+   * @param {string} value 图片地址或本地路径
+   * @returns {string | null}
+   * @protected
+   */
+  localImageFile(value) {
+    let file = null;
+    if (value.startsWith("file://")) {
+      file = fileURLToPath2(value);
+    } else if (path.isAbsolute(value)) {
+      file = value;
+    }
+    return file && existsSync(file) ? file : null;
+  }
+  /**
+   * 获取图片 MIME 类型
+   * @param {string} file 图片路径
+   * @returns {string}
+   * @protected
+   */
+  imageMimeType(file) {
+    const ext = path.extname(file).toLowerCase();
+    const types = {
+      ".apng": "image/apng",
+      ".avif": "image/avif",
+      ".bmp": "image/bmp",
+      ".gif": "image/gif",
+      ".ico": "image/x-icon",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".png": "image/png",
+      ".svg": "image/svg+xml",
+      ".webp": "image/webp"
+    };
+    return types[ext] ?? "application/octet-stream";
+  }
+  /**
+   * 内置命令
+   * @returns {XoMenu.CommandHandlerMap}
+   * @protected
+   */
+  builtInCommands() {
+    return {
+      /* --- Electron 内置命令 --- */
+      // 编辑命令
+      [MenuCommands.editUndo]: (record) => record.window.webContents.undo(),
+      [MenuCommands.editRedo]: (record) => record.window.webContents.redo(),
+      [MenuCommands.editCut]: (record) => record.window.webContents.cut(),
+      [MenuCommands.editCopy]: (record) => record.window.webContents.copy(),
+      [MenuCommands.editPaste]: (record) => record.window.webContents.paste(),
+      [MenuCommands.editDelete]: (record) => record.window.webContents.delete(),
+      [MenuCommands.editSelectAll]: (record) => record.window.webContents.selectAll(),
+      // 窗口命令
+      [MenuCommands.windowReload]: (record) => record.window.webContents.reload(),
+      [MenuCommands.windowForceReload]: (record) => record.window.webContents.reloadIgnoringCache(),
+      [MenuCommands.windowMinimize]: (record) => record.window.minimize(),
+      [MenuCommands.windowToggleFullscreen]: (record) => record.window.setFullScreen(!record.window.isFullScreen()),
+      [MenuCommands.windowClose]: (record) => record.window.close(),
+      [MenuCommands.windowToggleDevTools]: (record) => {
+        const webContents = record.window.webContents;
+        webContents.isDevToolsOpened() ? webContents.closeDevTools() : webContents.openDevTools();
+      },
+      /* --- Xion 框架内置命令 --- */
+      // 链接命令
+      [MenuCommands.linkOpen]: this.toCommandHandler((record, _payload) => MenuItems.openLink(record.state.linkURL)),
+      [MenuCommands.linkCopy]: this.toCommandHandler((record, _payload) => MenuItems.copyLink(record.state.linkURL)),
+      // 图片命令
+      [MenuCommands.imageOpen]: this.toCommandHandler((record, _payload) => MenuItems.openImage(record.state)),
+      [MenuCommands.imageSaveAs]: this.toCommandHandler((record, _payload) => MenuItems.saveImageAs(record.state)),
+      [MenuCommands.imageCopy]: this.toCommandHandler((record, _payload) => MenuItems.copyImage(record.state)),
+      [MenuCommands.imageCopyLink]: this.toCommandHandler((record, _payload) => MenuItems.copyImageLink(record.state))
+    };
+  }
+  /**
+   * 菜单项转命令处理器
+   * @param {(record: XoMenu.ContextMenuRecord, payload: any) => XoMenu.Item} item 菜单项
+   * @returns {XoMenu.CommandHandler}
+   * @protected
+   */
+  toCommandHandler(item) {
+    return async (record, payload) => {
+      await this.executeClick(item(record, payload), record);
+    };
+  }
+  /**
+   * 执行菜单项点击事件
+   * @param {XoMenu.Item}              item   菜单项
+   * @param {XoMenu.ContextMenuRecord} record 上下文菜单缓存
+   * @returns {Promise<void>}
+   * @protected
+   */
+  async executeClick(item, record) {
+    if (item.visible === false || item.enabled === false || !item.click) {
+      return;
+    }
+    void item.click({}, record.window, {});
+  }
+  /**
+   * 注册菜单命令
+   * @param {XoMenu.Command}        command 命令
+   * @param {XoMenu.CommandHandler} handler 处理器
+   */
+  registerCommand(command, handler) {
+    this.commandHandlers.set(command, handler);
+  }
+  /**
+   * 批量注册菜单命令
+   * @protected
+   */
+  registerCommands() {
+    const commands = {
+      // 内置命令
+      ...this.builtInCommands(),
+      // 业务命令
+      ...this.commands()
+    };
+    for (let [command, handler] of Object.entries(commands)) {
+      this.registerCommand(command, handler);
+    }
+  }
+  /**
+   * 执行菜单命令
+   * @param {XoMenu.ExecuteCommandRequest} request 请求
+   * @returns {Promise<boolean>}
+   */
+  async executeCommand(request) {
+    const { requestId, command, payload } = request;
+    const record = this.contextMenuRecords.get(requestId);
+    if (!record) {
+      return false;
+    }
+    this.deleteContextMenuRecord(requestId);
+    if (record.window.isDestroyed()) {
+      return false;
+    }
+    const handler = this.commandHandlers.get(command);
+    if (!handler) {
+      return false;
+    }
+    try {
+      await handler(record, payload);
+    } catch (err) {
+      this.xoApp.appLog.error("[Menu executeCommand]", err);
+      throw err;
+    }
+    return true;
+  }
+  /**
+   * 删除上下文菜单缓存
+   * @param {string} requestId 请求 ID
+   * @protected
+   */
+  deleteContextMenuRecord(requestId) {
+    const record = this.contextMenuRecords.get(requestId);
+    if (!record) {
+      return;
+    }
+    clearTimeout(record.timer);
+    this.contextMenuRecords.delete(requestId);
+  }
+  //</editor-fold>
+  //<editor-fold desc="辅助方法">
+  /**
+   * 解析上下文菜单类型
+   * @param {Electron.ContextMenuParams} params 上下文菜单参数
+   * @returns {XoMenu.Type}
+   */
+  contextType(params) {
+    if (!params) {
+      return "default";
+    }
+    if (params.isEditable) {
+      return "input";
+    }
+    if (params.selectionText.length > 0) {
+      return "selection";
+    }
+    if (params.mediaType === "image" || params.hasImageContents) {
+      return "image";
+    }
+    if (params.linkURL.length > 0) {
+      return "link";
+    }
+    return "default";
+  }
+  /**
+   * 解析上下文菜单状态
+   * @param {Electron.ContextMenuParams} params 上下文菜单参数
+   * @returns {XoMenu.ContextState}
+   */
+  contextState(params) {
+    return params ? {
+      canUndo: params.editFlags.canUndo,
+      canRedo: params.editFlags.canRedo,
+      hasSelection: params.selectionText.length > 0,
+      isPassword: params.formControlType === "input-password",
+      canCut: params.editFlags.canCut,
+      canCopy: params.editFlags.canCopy,
+      canPaste: params.editFlags.canPaste,
+      canDelete: params.editFlags.canDelete,
+      canSelectAll: params.editFlags.canSelectAll,
+      canEditRichly: params.editFlags.canEditRichly,
+      linkURL: params.linkURL,
+      srcURL: params.srcURL,
+      suggestedFilename: params.suggestedFilename,
+      mediaType: params.mediaType,
+      hasImageContents: params.hasImageContents,
+      x: params.x,
+      y: params.y
+    } : {};
+  }
+  /**
+   * 菜单项去重键
+   * @param {XoMenu.Item} item 菜单项
+   * @returns {string | undefined}
+   */
+  menuItemKey(item) {
+    if (item.id) {
+      return `id:${item.id}`;
+    }
+    if (item.role && item.label) {
+      return `role:${item.role}:${item.label}`;
+    }
+    return item.label ? `label:${item.label}` : void 0;
+  }
+  /**
+   * 创建菜单
+   * @param {XoMenu.Item[]} items 菜单项
+   * @returns {Electron.Menu}
+   */
+  buildMenu(items) {
+    return Menu.buildFromTemplate(items);
+  }
+  //</editor-fold>
+  //<editor-fold desc="菜单项">
+  /**
+   * 默认窗口菜单项
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  defaultMenuItems(state) {
+    const focusedWindow = BrowserWindow2.getFocusedWindow();
+    const isMinimizable = focusedWindow?.isMinimizable();
+    const isFullScreenable = focusedWindow?.isFullScreenable();
+    const isClosable = focusedWindow?.isClosable();
+    return this.autoSeparator(
+      [
+        MenuItems.copy(state.canCopy ?? state.hasSelection ?? false),
+        MenuItems.selectAll(state.canSelectAll ?? true)
+      ],
+      [
+        MenuItems.reload(!app2.isPackaged),
+        MenuItems.forceReload(!app2.isPackaged),
+        ...isMinimizable ? [MenuItems.minimize()] : [],
+        ...isFullScreenable ? [MenuItems.toggleFullscreen()] : [],
+        ...isClosable ? [MenuItems.close()] : []
+      ],
+      [
+        MenuItems.toggleDevTools()
+      ]
+    );
+  }
+  /**
+   * 获取页面基于内容的菜单项
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  contentMenuItems(state) {
+    return this.autoSeparator(
+      this.linkMenuItems(state),
+      this.imageMenuItems(state)
+    );
+  }
+  /**
+   * 获取应用菜单项
+   * @returns {XoMenu.Item[]}
+   */
+  applicationMenuItems() {
+    return [
+      MenuItems.group(
+        "\u7F16\u8F91",
+        [
+          ...this.autoSeparator(
+            [
+              MenuItems.undo(),
+              MenuItems.redo()
+            ],
+            [
+              MenuItems.cut(),
+              MenuItems.copy(),
+              MenuItems.paste(),
+              MenuItems.del()
+            ],
+            [
+              MenuItems.selectAll()
+            ]
+          )
+        ]
+      ),
+      MenuItems.group(
+        "\u7A97\u53E3",
+        [
+          ...this.autoSeparator(
+            [
+              MenuItems.reload(!app2.isPackaged),
+              MenuItems.forceReload(!app2.isPackaged)
+            ],
+            [
+              MenuItems.minimize(),
+              MenuItems.toggleFullscreen(),
+              MenuItems.close()
+            ],
+            [
+              MenuItems.toggleDevTools()
+            ]
+          )
+        ]
+      )
+    ];
+  }
+  /**
+   * 获取托盘菜单项
+   * @returns {XoMenu.Item[]}
+   */
+  trayMenuItems() {
+    return this.autoSeparator(
+      [
+        MenuItems.showMainWindow(this.xoApp)
+      ],
+      [
+        MenuItems.showSettingWindow(this.xoApp),
+        MenuItems.checkForUpdate(this.xoApp)
+      ],
+      [
+        MenuItems.appQuit(this.xoApp)
+      ]
+    );
+  }
+  /**
+   * 获取链接菜单项
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  linkMenuItems(state) {
+    return this.autoSeparator(
+      [
+        MenuItems.openLink(state.linkURL),
+        MenuItems.copyLink(state.linkURL)
+      ]
+    );
+  }
+  /**
+   * 获取图片菜单项
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  imageMenuItems(state) {
+    return this.autoSeparator(
+      [
+        MenuItems.openImage(state),
+        MenuItems.saveImageAs(state),
+        MenuItems.copyImage(state),
+        MenuItems.copyImageLink(state)
+      ]
+    );
+  }
+  /**
+   * 获取编辑菜单项
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  editableMenuItems(state) {
+    return this.autoSeparator(
+      [
+        MenuItems.undo(state.canUndo ?? false),
+        MenuItems.redo(state.canRedo ?? false)
+      ],
+      [
+        MenuItems.cut(state.canCut ?? false),
+        MenuItems.copy(state.canCopy ?? false),
+        MenuItems.paste(state.canPaste ?? state.hasClipboard ?? true),
+        MenuItems.del(state.canDelete ?? false)
+      ],
+      [
+        MenuItems.selectAll(state.canSelectAll ?? true)
+      ]
+    );
+  }
+  /**
+   * 获取选区菜单项
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  selectionMenuItems(state) {
+    return this.autoSeparator(
+      [
+        MenuItems.copy(state.canCopy ?? state.hasSelection ?? false),
+        MenuItems.selectAll(state.canSelectAll ?? true)
+      ]
+    );
+  }
+  /**
+   * 按上下文获取菜单项
+   * @param {XoMenu.Type}         type  菜单类型
+   * @param {XoMenu.ContextState} state 上下文状态
+   * @returns {XoMenu.Item[]}
+   */
+  contextMenuItems(type, state) {
+    const contentItems = this.contentMenuItems(state);
+    switch (type) {
+      case "input":
+      case "editable":
+        return this.autoSeparator(
+          contentItems,
+          this.editableMenuItems(state)
+        );
+      case "selection":
+        return this.autoSeparator(
+          contentItems,
+          this.selectionMenuItems(state)
+        );
+      case "link":
+      case "image":
+        return this.autoSeparator(
+          contentItems
+        );
+      case "tray":
+        return this.trayMenuItems();
+      case "all":
+        return this.autoSeparator(
+          contentItems,
+          this.editableMenuItems(state),
+          this.defaultMenuItems(state)
+        );
+      case "app":
+      case "default":
+      default:
+        return this.autoSeparator(
+          contentItems,
+          this.defaultMenuItems(state)
+        );
+    }
+  }
+  /**
+   * 自动添加分割线
+   * @param {XoMenu.Item[][]} groups 菜单分组
+   * @returns {XoMenu.Item[]}
+   */
+  autoSeparator(...groups) {
+    const exists = /* @__PURE__ */ new Set();
+    return groups.map((group) => group.filter((item) => {
+      if (item.visible === false) {
+        return false;
+      }
+      const key = this.menuItemKey(item);
+      if (!key) {
+        return true;
+      }
+      if (exists.has(key)) {
+        return false;
+      }
+      exists.add(key);
+      return true;
+    })).filter((group) => group.length > 0).flatMap((group, index) => {
+      return index <= 0 ? group : [MenuItems.separator(), ...group];
+    });
+  }
+  //</editor-fold>
+};
+
+// src/main/menu/menu-manager.ts
+var MenuManager = class extends MenuManagerAbstract {
+  /**
+   * 业务命令
+   * @returns {XoMenu.CommandHandlerMap}
+   */
+  commands() {
+    return {};
+  }
+};
+
+export {
+  MenuItems,
+  MenuManagerAbstract,
+  MenuManager
+};