@e-xi/xion 0.0.6

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

@@ -0,0 +1,627 @@
+import {
+  XionName
+} from "./chunk-YLZRRUY7.js";
+import {
+  TrayLifecycle,
+  defineTrayConfig
+} from "./chunk-Q7YMMN7J.js";
+
+// src/main/tray/tray-icon.ts
+import { nativeImage } from "electron";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var currentDir = path.dirname(fileURLToPath(import.meta.url));
+function resolveTrayIconsDir() {
+  return path.resolve(currentDir, "../main/tray/icons");
+}
+var TrayIcon = class {
+  //<editor-fold desc="属性/构造">
+  /**
+   * 托盘配置
+   * @type {XoTray.Config | undefined}
+   * @private
+   */
+  config;
+  /**
+   * 构造函数
+   * @param {XoTray.Config} config 托盘配置
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  //</editor-fold>
+  //<editor-fold desc="托盘图标">
+  /**
+   * 内置图标键值表
+   * @returns {Record<XoTray.BuiltInIconName, string>}
+   */
+  builtInIcons() {
+    const iconDir = resolveTrayIconsDir();
+    return {
+      focus: path.resolve(iconDir, "focus.ico"),
+      blur: path.resolve(iconDir, "blur.ico"),
+      success: path.resolve(iconDir, "success.ico"),
+      error: path.resolve(iconDir, "error.ico"),
+      online: path.resolve(iconDir, "online.ico"),
+      offline: path.resolve(iconDir, "offline.ico"),
+      none: path.resolve(iconDir, "none.ico")
+    };
+  }
+  /**
+   * 创建图标映射表
+   * @returns {Map<XoTray.IconName, XoTray.Icon>}
+   */
+  toMap() {
+    return new Map([
+      ...Object.entries(this.builtInIcons()),
+      ...Object.entries(this.config?.icons ?? {})
+    ]);
+  }
+  /**
+   * 解析图标
+   * @param {XoTray.IconName} name 图标名称
+   * @returns {XoTray.Icon|undefined}
+   */
+  resolve(name) {
+    if (!name) {
+      return void 0;
+    }
+    return this.toMap().get(name);
+  }
+  /**
+   * 解析图标
+   * @param {XoTray.IconName} name 图标名称
+   * @returns {XoTray.Icon}
+   */
+  requireResolve(name) {
+    return this.resolve(name) ?? this.toMap().get("focus") ?? this.builtInIcons().focus;
+  }
+  //</editor-fold>
+  //<editor-fold desc="工具方法">
+  /**
+   * 转换成 NativeImage
+   * @param {XoTray.Icon} icon 图标
+   * @returns {Electron.NativeImage}
+   */
+  toNativeImage(icon) {
+    if (typeof icon === "string") {
+      return nativeImage.createFromPath(icon);
+    }
+    return icon;
+  }
+  /**
+   * 判断图标是否可用
+   * @param {XoTray.Icon | undefined} icon 图标
+   * @returns {boolean}
+   */
+  valid(icon) {
+    if (!icon) {
+      return false;
+    }
+    if (typeof icon === "string") {
+      return fs.existsSync(icon);
+    }
+    return !icon.isEmpty();
+  }
+  //</editor-fold>
+};
+
+// src/main/tray/tray-animation.ts
+var TrayAnimation = class {
+  //<editor-fold desc="属性">
+  /**
+   * 托盘配置
+   * @type {XoTray.Config | undefined}
+   * @private
+   */
+  config;
+  /**
+   * 托盘图标
+   * @type {TrayIcon}
+   * @private
+   */
+  trayIcon;
+  //</editor-fold>
+  //<editor-fold desc="构造函数">
+  /**
+   * 构造函数
+   * @param {XoTray.Config} config   托盘配置
+   * @param {TrayIcon}      trayIcon 托盘图标
+   */
+  constructor(config, trayIcon) {
+    this.config = config;
+    this.trayIcon = trayIcon ?? new TrayIcon(this.config);
+  }
+  //</editor-fold>
+  //<editor-fold desc="动画管理">
+  /**
+   * 内置动画集合
+   * @returns {Record<XoTray.BuiltInAnimationName, XoTray.Animation>}
+   */
+  builtInAnimations() {
+    return {
+      // 闪烁
+      blink: {
+        interval: 400,
+        icons: ["focus", "none"]
+      },
+      // 连接中
+      connecting: {
+        interval: 400,
+        icons: ["online", "offline"]
+      }
+    };
+  }
+  /**
+   * 创建动画映射表
+   * @returns {Map<XoTray.AnimationName, XoTray.Animation>}
+   */
+  toMap() {
+    return new Map([
+      ...Object.entries(this.builtInAnimations()),
+      ...Object.entries(this.config?.animations ?? {})
+    ]);
+  }
+  /**
+   * 获取动画
+   * @param {XoTray.AnimationName} name 动画名称
+   * @returns {XoTray.Animation | undefined}
+   */
+  getAnimation(name) {
+    return this.toMap().get(name);
+  }
+  /**
+   * 解析动画帧
+   * @param {XoTray.AnimationName} name             动画名称
+   * @param {XoTray.IconName}      fallbackIconName 回退图标名称
+   * @returns {XoTray.Icon[]}
+   */
+  resolveFrames(name, fallbackIconName) {
+    const animation = this.getAnimation(name);
+    if (!animation?.icons?.length) {
+      return [this.trayIcon.requireResolve(fallbackIconName)];
+    }
+    return animation.icons.map((iconName) => this.trayIcon.requireResolve(iconName)).filter((icon) => this.trayIcon.valid(icon));
+  }
+  //</editor-fold>
+};
+
+// src/main/tray/tray-manager.ts
+import { Tray } from "electron";
+var TrayManager = class {
+  //<editor-fold desc="内部属性">
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @private
+   */
+  xoApp;
+  /**
+   * 托盘生命周期
+   * @type {TrayLifecycleAbstract}
+   * @private
+   */
+  lifecycle;
+  /**
+   * 托盘配置
+   * @type {XoTray.Config | undefined}
+   * @private
+   */
+  config;
+  /**
+   * 托盘实例
+   * @type {Electron.Tray | null}
+   * @private
+   */
+  tray = null;
+  /**
+   * 托盘图标管理器
+   * @type {TrayIcon}
+   * @private
+   */
+  trayIcon;
+  /**
+   * 托盘动画管理器
+   * @type {TrayAnimation}
+   * @private
+   */
+  trayAnimation;
+  /**
+   * 当前托盘图标名称
+   * @type {XoTray.IconName}
+   * @private
+   */
+  iconName;
+  /**
+   * 动画定时器
+   * @type {NodeJS.Timeout | null}
+   * @private
+   */
+  animationTimer = null;
+  /**
+   * 点击定时器
+   * @type {NodeJS.Timeout | null}
+   * @private
+   */
+  clickTimer = null;
+  //</editor-fold>
+  //<editor-fold desc="构造函数">
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   * @param {XoTray.Config}    config   托盘配置
+   */
+  constructor(xoApp, config) {
+    this.xoApp = xoApp;
+    const trayConfig = defineTrayConfig(config);
+    const productName = this.xoApp.getAppConfig()?.eletronAppConfig?.productName?.trim();
+    trayConfig.tooltip = config?.tooltip ?? productName ?? XionName;
+    trayConfig.blurTooltip = config?.blurTooltip ?? `\u5355\u51FB\u6253\u5F00 ${productName ?? XionName}`;
+    this.config = trayConfig;
+    this.iconName = this.config?.iconName ?? "focus";
+    this.trayIcon = new TrayIcon(this.config);
+    this.trayAnimation = new TrayAnimation(this.config, this.trayIcon);
+  }
+  //</editor-fold>
+  //<editor-fold desc="Getter">
+  /**
+   * 是否启用托盘
+   * @returns {boolean}
+   */
+  enabled() {
+    return this.config?.enabled ?? false;
+  }
+  /**
+   * 获取托盘实例
+   * @returns {Electron.Tray | null}
+   */
+  getTray() {
+    return this.tray;
+  }
+  /**
+   * 获取托盘配置
+   * @returns {XoTray.Config | undefined}
+   */
+  getConfig() {
+    return this.config;
+  }
+  //</editor-fold>
+  //<editor-fold desc="托盘控制">
+  /**
+   * 创建托盘
+   * @returns {Promise<Electron.Tray | null>}
+   */
+  async create() {
+    if (!this.enabled()) {
+      return null;
+    }
+    if (this.tray && !this.tray.isDestroyed()) {
+      return this.tray;
+    }
+    try {
+      const icon = this.trayIcon.requireResolve(this.iconName);
+      this.tray = new Tray(icon);
+      const lifecycle = this.createLifecycle(this.tray);
+      await lifecycle.beforeCreated();
+      this.xoApp.trayLog.debug("[\u6258\u76D8\u521B\u5EFA\u524D]\u751F\u547D\u5468\u671F\u52A0\u8F7D\u5B8C\u6210");
+      this.setFocusToolTip();
+      const menu = this.xoApp.getMenuManager().getTrayMenu();
+      this.tray?.setContextMenu(menu);
+      this.bindLifecycle(this.tray);
+      await lifecycle.afterCreated();
+      this.xoApp.trayLog.debug("[\u6258\u76D8\u521B\u5EFA\u540E]\u751F\u547D\u5468\u671F\u52A0\u8F7D\u5B8C\u6210");
+      this.xoApp.trayLog.debug("\u6258\u76D8\u521D\u59CB\u5316\u5B8C\u6210");
+      return this.tray;
+    } catch (error) {
+      this.destroy();
+      this.xoApp.trayLog.error("\u6258\u76D8\u521B\u5EFA\u5931\u8D25", error);
+      await this.lifecycle?.onError({ source: "TrayManager.create()", error });
+      throw error;
+    }
+  }
+  /**
+   * 设置聚焦时托盘提示（默认）
+   */
+  setFocusToolTip() {
+    this.setToolTip(this.config?.tooltip);
+  }
+  /**
+   * 设置失焦时的托盘提示
+   */
+  setBlurToolTip() {
+    this.setToolTip(this.config?.blurTooltip);
+  }
+  /**
+   * 设置托盘提示
+   * @param {string} tooltip 托盘提示
+   */
+  setToolTip(tooltip) {
+    tooltip ??= this.xoApp.getAppConfig()?.eletronAppConfig?.productName;
+    if (tooltip) {
+      this.tray?.setToolTip(tooltip);
+    }
+  }
+  /**
+   * 激活托盘气泡
+   * @param {Electron.DisplayBalloonOptions} options 气泡配置
+   */
+  displayBalloon(options) {
+    this.tray?.displayBalloon(options);
+    this.xoApp.trayLog.debug("\u6258\u76D8\u6C14\u6CE1\u5DF2\u6FC0\u6D3B");
+  }
+  /**
+   * 关闭托盘气泡
+   */
+  removeBalloon() {
+    this.tray?.removeBalloon();
+    this.xoApp.trayLog.debug("\u6258\u76D8\u6C14\u6CE1\u5DF2\u5173\u95ED");
+  }
+  /**
+   * 设置托盘图标
+   * @param {XoTray.IconName} name 图标名称
+   */
+  setIcon(name) {
+    this.iconName = name;
+    if (!this.tray || this.tray.isDestroyed()) {
+      return;
+    }
+    this.stopAnimation();
+    const icon = this.trayIcon.requireResolve(name);
+    if (!this.trayIcon.valid(icon)) {
+      this.xoApp.trayLog.warn("\u6258\u76D8\u56FE\u6807\u65E0\u6548", { name });
+      return;
+    }
+    this.tray.setImage(icon);
+    this.xoApp.trayLog.debug("\u6258\u76D8\u56FE\u6807\u5DF2\u5207\u6362", { name });
+  }
+  /**
+   * 托盘聚焦
+   */
+  setFocus() {
+    this.setIcon("focus");
+    this.setFocusToolTip();
+  }
+  /**
+   * 托盘失焦
+   */
+  setBlur() {
+    this.setIcon("blur");
+    this.setBlurToolTip();
+  }
+  /**
+   * 销毁托盘
+   */
+  destroy() {
+    this.stopAnimation();
+    this.clearClickTimer();
+    if (!this.tray || this.tray.isDestroyed()) {
+      return;
+    }
+    this.tray.destroy();
+    this.tray = null;
+    this.lifecycle = void 0;
+    this.xoApp.trayLog.debug("\u6258\u76D8\u5DF2\u9500\u6BC1");
+  }
+  //</editor-fold>
+  //<editor-fold desc="动画控制">
+  /**
+   * 启动托盘动画
+   * @param {XoTray.AnimationName} name 动画名称
+   */
+  startAnimation(name) {
+    if (!this.tray || this.tray.isDestroyed()) {
+      return;
+    }
+    if (!name) {
+      return;
+    }
+    const animation = this.trayAnimation.getAnimation(name);
+    const frames = this.trayAnimation.resolveFrames(name, this.iconName);
+    if (frames.length <= 1) {
+      return;
+    }
+    this.stopAnimation();
+    const interval = animation?.interval ?? 400;
+    let index = 0;
+    this.tray.setImage(frames[index]);
+    this.animationTimer = setInterval(() => {
+      if (!this.tray || this.tray.isDestroyed()) {
+        this.stopAnimation();
+        return;
+      }
+      index = (index + 1) % frames.length;
+      this.tray.setImage(frames[index]);
+    }, interval);
+    this.xoApp.trayLog.debug("\u6258\u76D8\u52A8\u753B\u5DF2\u542F\u52A8", {
+      name,
+      interval,
+      frames: frames.length
+    });
+  }
+  /**
+   * 停止托盘动画
+   * @param {XoTray.IconName} name 图标名称
+   */
+  stopAnimation(name) {
+    if (!this.animationTimer) {
+      return;
+    }
+    clearInterval(this.animationTimer);
+    this.animationTimer = null;
+    if (this.tray && !this.tray.isDestroyed()) {
+      const icon = this.trayIcon.requireResolve(name ?? this.iconName);
+      if (this.trayIcon.valid(icon)) {
+        this.tray.setImage(icon);
+      }
+    }
+    this.xoApp.trayLog.debug("\u6258\u76D8\u52A8\u753B\u5DF2\u505C\u6B62");
+  }
+  //</editor-fold>
+  //<editor-fold desc="生命周期">
+  /**
+   * 创建托盘生命周期
+   * @param {Electron.Tray} tray 托盘实例
+   * @returns {TrayLifecycleAbstract} 托盘生命周期
+   * @private
+   */
+  createLifecycle(tray) {
+    this.lifecycle = new (this.config?.lifecycle ?? TrayLifecycle)(this.xoApp, tray);
+    return this.lifecycle;
+  }
+  /**
+   * 获取托盘生命周期
+   * @returns {TrayLifecycleAbstract} 托盘生命周期
+   * @private
+   */
+  getLifecycle() {
+    if (!this.lifecycle) {
+      throw new Error("\u6258\u76D8\u751F\u547D\u5468\u671F\u672A\u521D\u59CB\u5316");
+    }
+    return this.lifecycle;
+  }
+  /**
+   * 绑定托盘生命周期
+   * @param {Electron.Tray} tray 托盘实例
+   * @private
+   */
+  bindLifecycle(tray) {
+    const lifecycle = this.getLifecycle();
+    tray.on("click", (event, bounds, position) => {
+      if (this.config?.debugPosition === true) {
+        this.xoApp.trayLog.debug("on:click", { bounds, position });
+      } else {
+        this.xoApp.trayLog.debug("on:click", { bounds });
+      }
+      this.delayClick(() => this.catcher("on:click", () => lifecycle.onClick(bounds, position, event)));
+    });
+    tray.on("double-click", (event, bounds) => {
+      this.xoApp.trayLog.debug("on:double-click", { bounds });
+      this.clearClickTimer();
+      this.catcher("on:double-click", () => lifecycle.onDoubleClick(bounds, event));
+    });
+    tray.on("right-click", (event, bounds) => {
+      this.xoApp.trayLog.debug("on:right-click", { bounds });
+      this.catcher("on:right-click", () => lifecycle.onRightClick(bounds, event));
+    });
+    tray.on("middle-click", (event, bounds) => {
+      this.xoApp.trayLog.debug("on:middle-click", { bounds });
+      this.catcher("on:middle-click", () => lifecycle.onMiddleClick(bounds, event));
+    });
+    tray.on("mouse-down", (event, position) => {
+      if (this.config?.debugPosition === true) {
+        this.xoApp.trayLog.debug("on:mouse-down", { position });
+      }
+      this.catcher("on:mouse-down", () => lifecycle.onMouseDown(position, event));
+    });
+    tray.on("mouse-enter", (event, position) => {
+      if (this.config?.debugPosition === true) {
+        this.xoApp.trayLog.debug("on:mouse-enter", { position });
+      }
+      this.catcher("on:mouse-enter", () => lifecycle.onMouseEnter(position, event));
+    });
+    tray.on("mouse-leave", (event, position) => {
+      if (this.config?.debugPosition === true) {
+        this.xoApp.trayLog.debug("on:mouse-leave", { position });
+      }
+      this.catcher("on:mouse-leave", () => lifecycle.onMouseLeave(position, event));
+    });
+    tray.on("mouse-move", (event, position) => {
+      if (this.config?.debugPosition === true) {
+        this.xoApp.trayLog.debug("on:mouse-move", { position });
+      }
+      this.catcher("on:mouse-move", () => lifecycle.onMouseMove(position, event));
+    });
+    tray.on("mouse-up", (event, position) => {
+      if (this.config?.debugPosition === true) {
+        this.xoApp.trayLog.debug("on:mouse-up", { position });
+      }
+      this.catcher("on:mouse-up", () => lifecycle.onMouseUp(position, event));
+    });
+    tray.on("balloon-show", () => {
+      this.xoApp.trayLog.debug("on:balloon-show");
+      this.catcher("on:balloon-show", () => lifecycle.onBalloonShow());
+    });
+    tray.on("balloon-click", () => {
+      this.xoApp.trayLog.debug("on:balloon-click");
+      this.catcher("on:balloon-click", () => lifecycle.onBalloonClick());
+    });
+    tray.on("balloon-closed", () => {
+      this.xoApp.trayLog.debug("on:balloon-closed");
+      this.catcher("on:balloon-closed", () => lifecycle.onBalloonClosed());
+    });
+    tray.on("drag-enter", () => {
+      this.xoApp.trayLog.debug("on:drag-enter");
+      this.catcher("on:drag-enter", () => lifecycle.onDragEnter());
+    });
+    tray.on("drag-leave", () => {
+      this.xoApp.trayLog.debug("on:drag-leave");
+      this.catcher("on:drag-leave", () => lifecycle.onDragLeave());
+    });
+    tray.on("drag-end", () => {
+      this.xoApp.trayLog.debug("on:drag-end");
+      this.catcher("on:drag-end", () => lifecycle.onDragEnd());
+    });
+    tray.on("drop", () => {
+      this.xoApp.trayLog.debug("on:drop");
+      this.catcher("on:drop", () => lifecycle.onDrop());
+    });
+    tray.on("drop-files", (event, files) => {
+      this.xoApp.trayLog.debug("on:drop-files", { files });
+      this.catcher("on:drop-files", () => lifecycle.onDropFiles(event, files));
+    });
+    tray.on("drop-text", (event, text) => {
+      this.xoApp.trayLog.debug("on:drop-text", { text });
+      this.catcher("on:drop-text", () => lifecycle.onDropText(event, text));
+    });
+  }
+  //</editor-fold>
+  //<editor-fold desc="点击计时器管理">
+  /**
+   * 延迟执行单击
+   * @param {() => void} runner 单击执行器
+   * @private
+   */
+  delayClick(runner) {
+    this.clearClickTimer();
+    this.clickTimer = setTimeout(() => {
+      this.clickTimer = null;
+      runner();
+    }, 220);
+  }
+  /**
+   * 清理单击定时器
+   * @private
+   */
+  clearClickTimer() {
+    if (!this.clickTimer) {
+      return;
+    }
+    clearTimeout(this.clickTimer);
+    this.clickTimer = null;
+  }
+  //</editor-fold>
+  //<editor-fold desc="事件错误捕捉器">
+  /**
+   * 事件错误捕捉器
+   * @param {string}                     source 事件来源
+   * @param {() => Promise<void> | void} runner 事件处理器
+   * @private
+   */
+  catcher(source, runner) {
+    try {
+      void Promise.resolve(runner()).catch((error) => {
+        void this.lifecycle?.onError({ source, error });
+      });
+    } catch (error) {
+      void this.lifecycle?.onError({ source, error });
+    }
+  }
+  //</editor-fold>
+};
+
+export {
+  TrayIcon,
+  TrayAnimation,
+  TrayManager
+};