@e-xi/xion 0.0.6

package/dist/chunk-files/chunk-5PKWVAQP.js

@@ -0,0 +1,92 @@
+import {
+  XionName
+} from "./chunk-YLZRRUY7.js";
+import {
+  AnsiColors
+} from "./chunk-P4CX6I4J.js";
+
+// package.json
+var version = "0.0.6";
+
+// src/main/banner/banner-abstract.ts
+var BannerAbstract = class {
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 获取 Banner
+   * @returns {string | undefined}
+   */
+  getBanner() {
+    const config = this.config();
+    const banner = this.banner();
+    if (!banner) {
+      return void 0;
+    }
+    const banners = banner.replaceAll("\r\n", "\n").split("\n");
+    if (config?.showVersion === true) {
+      banners.push(`${XionName} Version: v${version}`);
+      banners.push("");
+    }
+    if (!config?.color) {
+      return banners;
+    }
+    const colorCode = AnsiColors[config.color];
+    if (!colorCode) {
+      return banners;
+    }
+    return banners.map((line) => `${colorCode}${line}${AnsiColors.reset}`);
+  }
+  /**
+   * 打印 Banner 行
+   * @param {(line: string) => void} writer 写入器
+   */
+  printBannerLines(writer) {
+    const banner = this.getBanner();
+    banner && banner.forEach((line) => writer(line));
+  }
+};
+
+// src/main/banner/banner-manager.ts
+var BannerManager = class extends BannerAbstract {
+  /**
+   * 获取 Banner 配置
+   * @returns {XoBanner.Config}
+   * @protected
+   */
+  config() {
+    return {
+      color: "green",
+      showVersion: true
+    };
+  }
+  /**
+   * 设置 Banner
+   * https://patorjk.com/software/taag/
+   * font: Sub-Zero
+   * @returns {string}
+   */
+  banner() {
+    return String.raw`
+ __  __     __     ______     __   __
+/\_\_\_\   /\ \   /\  __ \   /\ "-.\ \
+\/_/\_\/_  \ \ \  \ \ \/\ \  \ \ \-.  \
+  /\_\/\_\  \ \_\  \ \_____\  \ \_\\"\_\
+  \/_/\/_/   \/_/   \/_____/   \/_/ \/_/
+`;
+  }
+};
+
+export {
+  BannerAbstract,
+  BannerManager
+};

package/dist/chunk-files/chunk-6BOPFOZD.js

@@ -0,0 +1,19 @@
+// src/shared/shortcut/consts/shortcut-id.ts
+var ShortcutIDPrefix = "ShortcutID_";
+
+// src/shared/utils/shortcut-util.ts
+var ShortcutUtil = class {
+  /**
+   * 创建快捷键ID
+   * @param {string} id 快捷键ID
+   * @returns {XoIpc.Channel}
+   */
+  static id(id) {
+    return `${ShortcutIDPrefix}${id}`;
+  }
+};
+
+export {
+  ShortcutIDPrefix,
+  ShortcutUtil
+};

package/dist/chunk-files/chunk-6FDO72PN.js

@@ -0,0 +1,25 @@
+// src/shared/utils/regexp-util.ts
+var RegexpUtil = class {
+  /**
+   * js 文件正则表达式 RegExp
+   * @type {RegExp}
+   */
+  static jsFile = /\.js$/;
+  /**
+   * js 系列文件正则表达式 RegExp，匹配 .cjs .mjs .js
+   * @type {RegExp}
+   */
+  static likeJsFile = /\.[cm]?js$/;
+  /**
+   * 是否为图片
+   * @param {string | null} str 字符串
+   * @returns {boolean}
+   */
+  static isImage(str) {
+    return /^(https?:|data:|\/|\.\/|\.\.\/).+\.(png|jpe?g|gif|svg|webp|ico)(\?.*)?$/i.test(str ?? "");
+  }
+};
+
+export {
+  RegexpUtil
+};

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

@@ -0,0 +1,67 @@
+import {
+  CommandBuild
+} from "./chunk-3XOVD6UX.js";
+import {
+  ModeDevelopment,
+  ModeProduction,
+  ModeStaging
+} from "./chunk-FMQTZ3QV.js";
+
+// src/vite/mode/vite-mode.ts
+var ViteMode = class {
+  /**
+   * 为 Vite 生产环境或 Vite 预发布环境
+   * @param {XoMode.ViteConfigEnv} env vite 环境
+   * @returns {boolean}
+   */
+  static likeProd(env) {
+    return [ModeProduction, ModeStaging].includes(this.getMode(env));
+  }
+  /**
+   * 是否为 Vite 生产环境
+   * @param {XoMode.ViteConfigEnv} env vite 环境
+   * @returns {boolean}
+   */
+  static isProd(env) {
+    return this.getMode(env) === ModeProduction;
+  }
+  /**
+   * 是否为 Vite 预发布环境
+   * @param {XoMode.ViteConfigEnv} env vite 环境
+   * @returns {boolean}
+   */
+  static isStaging(env) {
+    return this.getMode(env) === ModeStaging;
+  }
+  /**
+   * 是否为 Vite 开发环境
+   * @param {XoMode.ViteConfigEnv} env vite 环境
+   * @returns {boolean}
+   */
+  static isDev(env) {
+    return this.getMode(env) === ModeDevelopment;
+  }
+  /**
+   * 获取模式
+   * @param {XoMode.ViteConfigEnv} env vite 环境
+   * @returns {XoMode.Mode}
+   * @private
+   */
+  static getMode(env) {
+    if (env?.command?.trim().toLowerCase() === CommandBuild) {
+      return ModeProduction;
+    }
+    const mode = env?.mode?.trim().toLowerCase();
+    if (mode === ModeProduction) {
+      return ModeProduction;
+    }
+    if (mode === ModeStaging) {
+      return ModeStaging;
+    }
+    return ModeDevelopment;
+  }
+};
+
+export {
+  ViteMode
+};

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

@@ -0,0 +1,74 @@
+// src/main/store/jwt-auth-store.ts
+import { app, safeStorage } from "electron";
+import ElectronStore from "electron-store";
+import path from "node:path";
+var JwtAuthStore = class {
+  /** Electron Store */
+  store;
+  /**
+   * 构造函数
+   */
+  constructor() {
+    this.store = new ElectronStore({
+      name: "jwt-auth",
+      cwd: path.join(app.getPath("userData"), "auth"),
+      schema: {
+        session: { type: "string" }
+      }
+    });
+  }
+  /**
+   * 当前系统是否支持安全加密
+   * @returns {boolean}
+   */
+  isEncryptionAvailable() {
+    return safeStorage.isEncryptionAvailable();
+  }
+  /**
+   * 加密并保存会话
+   * @template TUser 用户类型
+   * @param {XoAuth.StoredRefreshSession<TUser>} session 会话数据
+   * @returns {boolean} 是否已持久化
+   */
+  setSession(session) {
+    if (!this.isEncryptionAvailable()) {
+      return false;
+    }
+    const encryptedSession = safeStorage.encryptString(JSON.stringify(session));
+    this.store.set("session", encryptedSession.toString("base64"));
+    return true;
+  }
+  /**
+   * 读取并解密会话
+   * @template TUser 用户类型
+   * @returns {XoAuth.StoredRefreshSession<TUser> | undefined}
+   */
+  getSession() {
+    const encryptedSession = this.store.get("session");
+    if (!encryptedSession || !this.isEncryptionAvailable()) {
+      return void 0;
+    }
+    try {
+      const content = safeStorage.decryptString(Buffer.from(encryptedSession, "base64"));
+      const session = JSON.parse(content);
+      if (!session.refreshToken?.trim() || !Number.isFinite(session.refreshTokenExpiresAt)) {
+        throw new Error("\u767B\u5F55\u4F1A\u8BDD\u6570\u636E\u65E0\u6548");
+      }
+      return session;
+    } catch {
+      this.clear();
+      throw new Error("\u767B\u5F55\u4F1A\u8BDD\u8BFB\u53D6\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+    }
+  }
+  /**
+   * 清除持久化会话
+   * @returns {void}
+   */
+  clear() {
+    this.store.delete("session");
+  }
+};
+
+export {
+  JwtAuthStore
+};

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

@@ -0,0 +1,60 @@
+import {
+  IpcUtil
+} from "./chunk-ID3YDA2K.js";
+
+// src/shared/ipc/channels/context-menu-channels.ts
+var ContextMenuChannels = class {
+  /** 执行菜单命令 */
+  static executeCommand = IpcUtil.channel("BuiltIn:ContextMenu:executeCommand");
+  /* ------ 监听通道 ------ */
+  /** 监听上下文菜单请求 */
+  static onRequested = IpcUtil.channel("BuiltIn:ContextMenu:onRequested");
+};
+
+// src/shared/ipc/channels/window-channels.ts
+var WindowChannels = class {
+  /** 渲染进程首屏渲染完成 */
+  static ready = IpcUtil.channel("BuiltIn:Window:ready");
+  /** 是否等待 Renderer 渲染完成后再显示窗口 */
+  static shouldShowAfterRendererReady = IpcUtil.channel("BuiltIn:Window:shouldShowAfterRendererReady");
+  /** 获取窗口状态 */
+  static getState = IpcUtil.channel("BuiltIn:Window:getState");
+  /** 获取当前已打开窗口标识 */
+  static getOpenedWindowIdentities = IpcUtil.channel("BuiltIn:Window:getOpenedWindowIdentities");
+  /** 最小化窗口 */
+  static minimize = IpcUtil.channel("BuiltIn:Window:minimize");
+  /** 最大化窗口 */
+  static maximize = IpcUtil.channel("BuiltIn:Window:maximize");
+  /** 是否已最大化 */
+  static isMaximized = IpcUtil.channel("BuiltIn:Window:isMaximized");
+  /** 取消最大化窗口 */
+  static unmaximize = IpcUtil.channel("BuiltIn:Window:unmaximize");
+  /** 全屏窗口 */
+  static fullScreen = IpcUtil.channel("BuiltIn:Window:fullScreen");
+  /** 退出全屏窗口 */
+  static exitFullScreen = IpcUtil.channel("BuiltIn:Window:exitFullScreen");
+  /** 重新加载窗口 */
+  static reload = IpcUtil.channel("BuiltIn:Window:reload");
+  /** 居中窗口 */
+  static center = IpcUtil.channel("BuiltIn:Window:center");
+  /** 隐藏窗口 */
+  static hide = IpcUtil.channel("BuiltIn:Window:hide");
+  /** 还原窗口 */
+  static restore = IpcUtil.channel("BuiltIn:Window:restore");
+  /** 切换窗口置顶 */
+  static toggleAlwaysOnTop = IpcUtil.channel("BuiltIn:Window:toggleAlwaysOnTop");
+  /** 切换侧边栏折叠 */
+  static toggleSidebarFold = IpcUtil.channel("BuiltIn:Window:toggleSidebarFold");
+  /** 关闭窗口 */
+  static close = IpcUtil.channel("BuiltIn:Window:close");
+  /* ------ 监听通道 ------ */
+  /** 监听窗口状态 */
+  static onState = IpcUtil.channel("BuiltIn:Window:onState");
+  /** 监听路由重定向 */
+  static onRouteRedirect = IpcUtil.channel("BuiltIn:Window:onRouteRedirect");
+};
+
+export {
+  ContextMenuChannels,
+  WindowChannels
+};

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

@@ -0,0 +1,319 @@
+import {
+  ShortcutHandlerIds
+} from "./chunk-Q7LCZIQP.js";
+import {
+  ShortcutUtil
+} from "./chunk-GROGDGEL.js";
+
+// src/main/shortcut/shortcut-handlers-abstract.ts
+var ShortcutHandlersAbstract = class {
+  /** Xion 应用 */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+};
+
+// src/main/shortcut/handlers/app-shortcut-handlers.ts
+var AppShortcutHandlers = class extends ShortcutHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoShortcut.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      /** 切换所有窗口显示状态 */
+      [ShortcutHandlerIds.toggleAllWindow]: async () => {
+        await this.xoApp.toggleAllWindowVisible();
+      },
+      /** 显示设置窗口 */
+      [ShortcutHandlerIds.showSettingWindow]: async () => {
+        await this.xoApp.showSettingWindow();
+      }
+    };
+  }
+};
+
+// src/main/shortcut/handlers/window-shortcut-handlers.ts
+var WindowShortcutHandlers = class extends ShortcutHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoShortcut.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      // /** 关闭当前窗口 */
+      // [ShortcutHandlerIds.closeWindow]: ({window}) => {
+      //     this.xoApp.getWindowManager().closeByWindow(window)
+      // },
+    };
+  }
+};
+
+// src/main/shortcut/shortcut-manager-abstract.ts
+import { app, BrowserWindow, globalShortcut } from "electron";
+var ShortcutManagerAbstract = class {
+  /** XionApp */
+  xoApp;
+  /** 是否已初始化 */
+  initialized = false;
+  /** 快捷键处理器 */
+  handlers = /* @__PURE__ */ new Map();
+  /** 已注册快捷键处理器类 */
+  registeredHandlerClasses = /* @__PURE__ */ new Set();
+  /** 已注册的全局快捷键 */
+  globalAccelerators = /* @__PURE__ */ new Map();
+  /** 应用内快捷键缓存 */
+  appShortcuts = [];
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp XionApp
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 初始化快捷键管理器
+   */
+  initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+    this.registerHandlers();
+    app.on("browser-window-created", (_event, window) => this.bindAppShortcut(window));
+    for (const window of BrowserWindow.getAllWindows()) {
+      this.bindAppShortcut(window);
+    }
+    this.updateAppShortcuts();
+    this.reRegisterGlobalShortcuts();
+  }
+  //<editor-fold desc="全局快捷键">
+  /**
+   * 重新注册全局快捷键
+   */
+  reRegisterGlobalShortcuts() {
+    this.unregisterGlobalShortcuts();
+    for (const shortcut of Object.values(this.getStoreShortcuts())) {
+      this.registerGlobalShortcut(shortcut);
+    }
+  }
+  /**
+   * 注册全局快捷键
+   * @param {XoShortcut.Key} shortcut 快捷键
+   */
+  registerGlobalShortcut(shortcut) {
+    if (shortcut.enabled === false || shortcut.scope !== "global") {
+      return;
+    }
+    const accelerator = ShortcutUtil.toAccelerator(shortcut.keys);
+    if (!accelerator) {
+      return;
+    }
+    if (globalShortcut.isRegistered(accelerator)) {
+      globalShortcut.unregister(accelerator);
+    }
+    const registered = globalShortcut.register(accelerator, () => {
+      void this.trigger({ source: "global", shortcut });
+    });
+    if (registered) {
+      this.globalAccelerators.set(shortcut.id, accelerator);
+    }
+  }
+  /**
+   * 注销全部全局快捷键
+   */
+  unregisterGlobalShortcuts() {
+    for (const accelerator of this.globalAccelerators.values()) {
+      globalShortcut.unregister(accelerator);
+    }
+    this.globalAccelerators.clear();
+  }
+  //</editor-fold>
+  //<editor-fold desc="快捷键处理器">
+  /**
+   * 注册快捷键处理器
+   * @param {XoShortcut.ID}      id      快捷键 ID
+   * @param {XoShortcut.Handler} handler 处理器
+   */
+  registerHandler(id, handler) {
+    if (this.handlers.has(id)) {
+      throw new Error(`\u5FEB\u6377\u952E\u5904\u7406\u5668\u91CD\u590D\u6CE8\u518C: ${id}`);
+    }
+    this.handlers.set(id, handler);
+  }
+  /**
+   * 注销快捷键处理器
+   * @param {XoShortcut.ID} id 快捷键 ID
+   */
+  unregisterHandler(id) {
+    this.handlers.delete(id);
+  }
+  /**
+   * 注册所有快捷键处理器
+   */
+  registerHandlers() {
+    const handlerClasses = [
+      // 内置应用快捷键处理器
+      AppShortcutHandlers,
+      // 内置窗口快捷键处理器
+      WindowShortcutHandlers,
+      // 自定义快捷键处理器
+      ...this.handlerClasses()
+    ];
+    for (const HandlerClass of handlerClasses) {
+      if (this.registeredHandlerClasses.has(HandlerClass)) {
+        throw new Error(`\u5FEB\u6377\u952E\u5904\u7406\u5668\u7C7B\u91CD\u590D\u6CE8\u518C: ${HandlerClass.name}`);
+      }
+      this.registeredHandlerClasses.add(HandlerClass);
+      const handlerMap = new HandlerClass(this.xoApp).handlerMap();
+      for (const [id, handler] of this.objectEntries(handlerMap)) {
+        this.registerHandler(id, handler);
+      }
+    }
+  }
+  /**
+   * 推导 Object.entries 的准确类型
+   * @param {Record<any, any>} value 对象
+   * @returns {Array<[any, any]>}
+   * @private
+   */
+  objectEntries(value) {
+    return Object.entries(value);
+  }
+  //</editor-fold>
+  //<editor-fold desc="快捷键存储和管理">
+  /**
+   * 获取快捷键缓存
+   * @returns {XoShortcut.KeyMap}
+   */
+  getStoreShortcuts() {
+    return this.xoApp.getAppStore().getShortcuts();
+  }
+  /**
+   * 设置快捷键
+   * @param {XoShortcut.KeyMap} shortcuts 快捷键
+   */
+  setShortcuts(shortcuts) {
+    const normalizedShortcuts = this.normalizeShortcuts(shortcuts);
+    this.xoApp.getAppStore().setShortcuts(normalizedShortcuts);
+    this.updateAppShortcuts(normalizedShortcuts);
+    this.reRegisterGlobalShortcuts();
+  }
+  /**
+   * 设置单个快捷键
+   * @param {XoShortcut.Key} shortcut 快捷键
+   */
+  setShortcut(shortcut) {
+    const shortcuts = this.getStoreShortcuts();
+    this.setShortcuts({
+      ...shortcuts,
+      [shortcut.id]: this.normalizeShortcut(shortcut)
+    });
+  }
+  /**
+   * 删除快捷键
+   * @param {XoShortcut.ID} id 快捷键 ID
+   */
+  deleteShortcut(id) {
+    const shortcuts = this.getStoreShortcuts();
+    delete shortcuts[id];
+    this.setShortcuts(shortcuts);
+  }
+  //</editor-fold>
+  //<editor-fold desc="应用快捷键管理">
+  /**
+   * 绑定应用内快捷键监听
+   * @param {Electron.BrowserWindow} window 窗口
+   */
+  bindAppShortcut(window) {
+    window.webContents.on("before-input-event", (event, input) => {
+      if (input.type !== "keyDown") {
+        return;
+      }
+      const shortcut = this.findAppShortcut(input);
+      if (!shortcut) {
+        return;
+      }
+      event.preventDefault();
+      void this.trigger({ source: "app", shortcut, window, input });
+    });
+  }
+  /**
+   * 查找匹配的应用内快捷键
+   * @param {Electron.Input} input 输入信息
+   * @returns {XoShortcut.Key | undefined}
+   */
+  findAppShortcut(input) {
+    return this.appShortcuts.find((shortcut) => ShortcutUtil.matchInput(shortcut.keys, input));
+  }
+  /**
+   * 更新应用内快捷键缓存
+   * @param {XoShortcut.KeyMap} shortcuts 快捷键
+   */
+  updateAppShortcuts(shortcuts = this.getStoreShortcuts()) {
+    this.appShortcuts = Object.values(shortcuts).map((shortcut) => this.normalizeShortcut(shortcut)).filter((shortcut) => shortcut.enabled !== false && shortcut.scope === "app");
+  }
+  //</editor-fold>
+  //<editor-fold desc="快捷键触发">
+  /**
+   * 触发快捷键处理器
+   * @param {XoShortcut.TriggerPayload} payload 触发载荷
+   */
+  async trigger(payload) {
+    const handler = this.handlers.get(payload.shortcut.id);
+    if (!handler) {
+      return;
+    }
+    await handler(payload);
+  }
+  //</editor-fold>
+  //<editor-fold desc="标准化工具">
+  /**
+   * 标准化快捷键映射
+   * @param {XoShortcut.KeyMap} shortcuts 快捷键映射
+   * @returns {XoShortcut.KeyMap}
+   */
+  normalizeShortcuts(shortcuts) {
+    return Object.fromEntries(
+      Object.values(shortcuts).map((shortcut) => [shortcut.id, this.normalizeShortcut(shortcut)])
+    );
+  }
+  /**
+   * 标准化快捷键
+   * @param {XoShortcut.Key} shortcut 快捷键
+   * @returns {XoShortcut.Key}
+   */
+  normalizeShortcut(shortcut) {
+    return {
+      ...shortcut,
+      scope: shortcut.scope === "global" ? shortcut.scope : "app",
+      keys: ShortcutUtil.normalizeKeys(shortcut.keys),
+      enabled: shortcut.enabled !== false
+    };
+  }
+  //</editor-fold>
+};
+
+// src/main/shortcut/shortcut-manager.ts
+var ShortcutManager = class extends ShortcutManagerAbstract {
+  /**
+   * 自定义快捷键处理器列表
+   * @returns {XoShortcut.HandlersConstructor[]}
+   */
+  handlerClasses() {
+    return [];
+  }
+};
+
+export {
+  ShortcutHandlersAbstract,
+  AppShortcutHandlers,
+  WindowShortcutHandlers,
+  ShortcutManagerAbstract,
+  ShortcutManager
+};