@e-xi/xion 0.0.6

package/dist/renderer/utils/index.js

@@ -0,0 +1,1522 @@
+// src/renderer/utils/auth-route-util.ts
+import { useXoAuthStore } from "../store/index";
+import { computed, ref, watch } from "vue";
+var AuthRouteUtil = class {
+  /** 启动判定页是否自动跳转 */
+  bootstrapAutoRedirect;
+  // 强制错误信息（用于调试页面）
+  forceErrorMessage;
+  /** 启动判定路由名称 */
+  bootstrapRouteName;
+  /** 认证成功后的默认业务路由名称 */
+  defaultRouteName;
+  /** 登录路由名称 */
+  loginRouteName;
+  /** 注销路由名称 */
+  logoutRouteName;
+  /** 找回密码路由名称 */
+  findPasswordRouteName;
+  /** 认证流程路由名称集合 */
+  authenticationRouteNames;
+  /**
+   * 构造认证路由工具
+   * @param {AuthRouteUtilOptions} options 认证路由选项
+   */
+  constructor(options) {
+    this.bootstrapAutoRedirect = options.bootstrapAutoRedirect;
+    this.forceErrorMessage = options.forceErrorMessage;
+    this.bootstrapRouteName = options.bootstrapRouteName;
+    this.defaultRouteName = options.defaultRouteName;
+    this.loginRouteName = options.loginRouteName;
+    this.logoutRouteName = options.logoutRouteName;
+    this.findPasswordRouteName = options.findPasswordRouteName;
+    this.authenticationRouteNames = this.createAuthenticationRouteNames([
+      this.bootstrapRouteName,
+      this.loginRouteName,
+      this.logoutRouteName,
+      this.findPasswordRouteName
+    ]);
+  }
+  /**
+   * 安装认证路由守卫（在路由包中使用）
+   * <p>需要在路由实例创建后调用</p>
+   * @param {Router} router 路由实例
+   * @returns {() => void} 移除路由守卫的方法
+   */
+  installGuard(router) {
+    let startupChecked = false;
+    let authStore;
+    const getAuthStore = () => authStore ??= useXoAuthStore();
+    const bootstrapPath = router.resolve({ name: this.bootstrapRouteName }).path;
+    const loginPath = router.resolve({ name: this.loginRouteName }).path;
+    return router.beforeEach((to) => {
+      const ignoreAuthRoute = this.isIgnoreAuthRoute(to);
+      if (to.name === this.bootstrapRouteName) {
+        startupChecked = true;
+        return true;
+      }
+      if (to.name === this.loginRouteName) {
+        const store2 = getAuthStore();
+        if (store2.isInitializing) {
+          return this.replaceRoute(this.bootstrapRouteName, to);
+        }
+        if (store2.isAuthenticated) {
+          return {
+            path: this.resolveRedirect(
+              router,
+              to.query.redirect,
+              [
+                bootstrapPath,
+                loginPath
+              ]
+            ),
+            // 必须使用 replace，避免返回登录页
+            replace: true
+          };
+        }
+        return true;
+      }
+      if (ignoreAuthRoute) {
+        return true;
+      }
+      if (!startupChecked) {
+        startupChecked = true;
+        return this.replaceRoute(this.bootstrapRouteName, to);
+      }
+      startupChecked = true;
+      const store = getAuthStore();
+      if (store.isInitializing) {
+        return this.replaceRoute(this.bootstrapRouteName, to);
+      }
+      if (store.isError) {
+        return this.replaceRoute(this.bootstrapRouteName, to);
+      }
+      if (!store.isAuthenticated) {
+        return this.replaceRoute(this.loginRouteName, to);
+      }
+      return true;
+    });
+  }
+  /**
+   * 监听认证状态并跳转到登录页或业务页（用于在 App.vue 中使用）
+   * <p>在登录页面，监听到认证状态成功后跳转业务页</p>
+   * <p>在业务页面，监听到认证状态失效后跳转登录页</p>
+   *
+   * @returns {WatchHandle}
+   */
+  appAuthStateRedirect() {
+    const authStore = useXoAuthStore();
+    return watch(
+      () => authStore.status,
+      () => {
+        const router = RouterUtil.getRouter();
+        const route = router.currentRoute.value;
+        if (authStore.isAuthenticated) {
+          if (route.name !== this.loginRouteName) {
+            return;
+          }
+          const loginPath = router.resolve({ name: this.loginRouteName }).path;
+          const bootstrapPath = router.resolve({ name: this.bootstrapRouteName }).path;
+          void router.replace({
+            path: this.resolveRedirect(
+              router,
+              route.query.redirect,
+              [
+                loginPath,
+                bootstrapPath
+              ]
+            )
+          });
+          return;
+        }
+        if (!authStore.isUnauthenticated) {
+          return;
+        }
+        if (this.isIgnoreAuthRoute(route)) {
+          return;
+        }
+        void router.replace(this.replaceRoute(this.loginRouteName, route));
+      },
+      {
+        immediate: true
+      }
+    );
+  }
+  /**
+   * 监听认证状态并跳转到登录页或业务页（在启动判定页中使用）
+   * <p>用于启动判定页面，根据认证状态完成首次路由跳转</p>
+   * @returns {BootstrapAuthStateRedirectResult}
+   */
+  bootstrapAuthStateRedirect() {
+    const authStore = useXoAuthStore();
+    const isError = computed(() => this.forceErrorMessage ? true : authStore.isError);
+    const error = computed(() => this.forceErrorMessage || authStore.error);
+    const router = RouterUtil.getRouter();
+    const retrying = ref(false);
+    let redirecting = false;
+    const resolveStartupRedirect = () => {
+      const route = router.currentRoute.value;
+      const loginPath = router.resolve({ name: this.loginRouteName }).path;
+      return this.resolveRedirect(
+        router,
+        route.query.redirect,
+        // 排除的路径不作为重定向目标
+        [
+          route.path,
+          loginPath
+        ]
+      );
+    };
+    const redirectByAuthState = async () => {
+      if (this.bootstrapAutoRedirect === false) {
+        return;
+      }
+      if (redirecting || authStore.isInitializing) {
+        return;
+      }
+      if (authStore.isAuthenticated) {
+        redirecting = true;
+        try {
+          await router.replace(resolveStartupRedirect());
+        } finally {
+          redirecting = false;
+        }
+        return;
+      }
+      if (authStore.isUnauthenticated) {
+        redirecting = true;
+        try {
+          await router.replace({
+            name: this.loginRouteName,
+            query: {
+              redirect: resolveStartupRedirect()
+            }
+          });
+        } finally {
+          redirecting = false;
+        }
+      }
+    };
+    const retryInitialize = async () => {
+      if (retrying.value) {
+        return;
+      }
+      retrying.value = true;
+      try {
+        await authStore.initialize();
+      } finally {
+        retrying.value = false;
+      }
+    };
+    const stop = watch(
+      () => authStore.status,
+      () => void redirectByAuthState(),
+      {
+        immediate: true
+      }
+    );
+    return {
+      isError,
+      error,
+      retrying,
+      stop,
+      retryInitialize
+    };
+  }
+  /**
+   * 判断重定向路径是否为安全的应用内部路径
+   *
+   * @param {Router}            router        路由实例
+   * @param {unknown}           value         待判断的路径
+   * @param {readonly string[]} excludedPaths 不允许跳转的路径
+   * @returns {value is string}
+   */
+  isSafeRedirect(router, value, excludedPaths) {
+    if (typeof value !== "string") {
+      return false;
+    }
+    if (!value.startsWith("/") || value.startsWith("//")) {
+      return false;
+    }
+    if (excludedPaths.includes(value)) {
+      return false;
+    }
+    try {
+      const resolvedRoute = router.resolve(value);
+      return resolvedRoute.name !== null && !this.isAuthenticationRouteName(resolvedRoute.name);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 解析认证完成后的重定向路径
+   *
+   * @param {Router}            router        路由实例
+   * @param {unknown}           redirect      路由查询参数中的目标路径
+   * @param {readonly string[]} excludedPaths 不允许跳转的路径
+   * @returns {string}
+   */
+  resolveRedirect(router, redirect, excludedPaths = []) {
+    if (this.isSafeRedirect(router, redirect, excludedPaths)) {
+      return redirect;
+    }
+    return router.resolve({ name: this.defaultRouteName }).fullPath;
+  }
+  /**
+   * 判断路由是否免认证
+   * @param {RouteLocationNormalized} route 当前路由
+   * @returns {boolean}
+   */
+  isIgnoreAuthRoute(route) {
+    return route.meta.ignoreAuth === true;
+  }
+  /**
+   * 判断路由名称是否属于认证流程路由
+   * @param {RouteRecordName | null | undefined} routeName 路由名称
+   * @returns {boolean}
+   */
+  isAuthenticationRouteName(routeName) {
+    if (routeName === null || routeName === void 0) {
+      return false;
+    }
+    return this.authenticationRouteNames.has(routeName);
+  }
+  /**
+   * 路由替换为指定路由名称的路由
+   * @param {RouteRecordName}                routeName 路由名称
+   * @param {RouteLocationNormalizedGeneric} to        目标路由
+   * @return {RouteLocationRaw}
+   * @private
+   */
+  replaceRoute(routeName, to) {
+    return {
+      name: routeName,
+      query: {
+        redirect: to.fullPath
+      },
+      // 必须使用 replace，避免返回 from 路由
+      replace: true
+    };
+  }
+  /**
+   * 创建新的认证路由名称集合
+   * @param {readonly (RouteRecordName | undefined)[]} names 路由名称数组
+   * @returns {ReadonlySet<RouteRecordName>}
+   * @private
+   */
+  createAuthenticationRouteNames(names) {
+    return new Set(names.filter((name) => name !== void 0));
+  }
+};
+
+// src/renderer/utils/context-util.ts
+var ContextUtil = class {
+  /**
+   * flex 布局表单上下文 Key
+   * @type {InjectionKey<XoComponent.FormFlexContext>}
+   */
+  static FormFlexKey = Symbol("XoFormFlexContext");
+};
+
+// src/renderer/utils/error-util.ts
+var ErrorUtil = class {
+  /**
+   * 抛出错误
+   * @param {string} message 错误消息
+   */
+  static throw(message) {
+    throw new Error(message);
+  }
+};
+
+// src/renderer/utils/keyboard-util.ts
+var ModifierKeys = ["control", "shift", "alt"];
+var NormalFriendlyMap = {
+  // 控制键
+  escape: "Esc",
+  esc: "Esc",
+  pageup: "PageUp",
+  pagedown: "PageDown",
+  home: "Home",
+  end: "End",
+  arrowup: "\u2191",
+  arrowdown: "\u2193",
+  arrowleft: "\u2190",
+  arrowright: "\u2192",
+  up: "\u2191",
+  down: "\u2193",
+  left: "\u2190",
+  right: "\u2192",
+  enter: "Enter",
+  return: "Enter",
+  tab: "Tab",
+  space: "Space",
+  backspace: "Backspace",
+  insert: "Insert",
+  delete: "Del",
+  printscreen: "PrintScreen",
+  capslock: "CapsLock",
+  numlock: "NumLock",
+  scrolllock: "ScrollLock",
+  // 符号
+  minus: "-",
+  equal: "=",
+  bracketleft: "[",
+  bracketright: "]",
+  backquote: "`",
+  backslash: "\\",
+  semicolon: ";",
+  quote: "'",
+  comma: ",",
+  period: ".",
+  slash: "/",
+  // 小键盘
+  numpaddivide: "Numpad /",
+  numpadmultiply: "Numpad *",
+  numpadsubtract: "Numpad -",
+  numpadadd: "Numpad +",
+  numpaddecimal: "Numpad .",
+  numpadenter: "Enter"
+};
+var MediaFriendlyMap = {
+  // 音量键
+  audiovolumemute: "Volume Mute",
+  audiovolumedown: "Volume Down",
+  audiovolumeup: "Volume Up",
+  // 媒体键
+  mediatracknext: "Media Next",
+  mediatrackprevious: "Media Previous",
+  mediaplaypause: "Media Play/Pause",
+  mediastop: "Media Stop"
+};
+var ModifierFriendlyMap = {
+  control: "Ctrl",
+  shift: "Shift",
+  alt: "Alt"
+};
+var ModifierKeyOrder = {
+  control: 0,
+  shift: 1,
+  alt: 2
+};
+var ModifierKeyMap = {
+  ctrl: "control",
+  control: "control",
+  controlleft: "control",
+  controlright: "control",
+  shift: "shift",
+  shiftleft: "shift",
+  shiftright: "shift",
+  alt: "alt",
+  altleft: "alt",
+  altright: "alt"
+};
+var KeyboardUtil = class _KeyboardUtil {
+  /**
+   * 按键按下处理器
+   * @param {KeyboardEvent} event 按键事件
+   * @param {string[]}      keys  当前按键
+   * @returns {string[]}
+   */
+  static keydown(event, keys) {
+    if (event.repeat) {
+      return keys;
+    }
+    const code = event.code.toLowerCase();
+    if (!_KeyboardUtil.isSupportedKey(code)) {
+      return keys;
+    }
+    return [.../* @__PURE__ */ new Set([...keys, code])];
+  }
+  /**
+   * 按键弹起处理器
+   * @param {KeyboardEvent} event 按键事件
+   * @param {string[]}      keys  当前按键
+   * @returns {string[]}
+   */
+  static keyup(event, keys) {
+    const code = event.code.toLowerCase();
+    return keys.filter((item) => item !== code);
+  }
+  /**
+   * 获取有效组合键
+   * @param {string[]} keys 按键组合
+   * @returns {string[]}
+   */
+  static getCombinationKeys(keys) {
+    const modifierKeys = /* @__PURE__ */ new Set();
+    const currentKeys = _KeyboardUtil.sortKeys([...new Set(keys.map((key) => key.toLowerCase()))]).filter((key) => _KeyboardUtil.isSupportedKey(key)).filter((key) => {
+      const modifierKey = _KeyboardUtil.getModifierKey(key);
+      if (!modifierKey) {
+        return true;
+      }
+      if (modifierKeys.has(modifierKey)) {
+        return false;
+      }
+      modifierKeys.add(modifierKey);
+      return true;
+    });
+    const hasValidModifier = [...modifierKeys].some((key) => key !== "shift");
+    const normalKeys = currentKeys.filter((key) => !_KeyboardUtil.isModifierKey(key) && !_KeyboardUtil.isMediaKey(key));
+    const hasFunctionKey = normalKeys.some((key) => _KeyboardUtil.isFunctionKey(key));
+    const mediaKeys = currentKeys.filter((key) => _KeyboardUtil.isMediaKey(key));
+    if (mediaKeys.length === 1 && normalKeys.length === 0) {
+      return currentKeys;
+    }
+    if ((hasValidModifier || hasFunctionKey) && normalKeys.length === 1) {
+      return currentKeys;
+    }
+    return [];
+  }
+  /**
+   * 将按键解析为友好展示
+   * @param {string[]} keys      按键组合
+   * @param {string}   delimiter 分隔符
+   * @returns {string}
+   */
+  static parseFriendly(keys, delimiter = " + ") {
+    return keys.map((key) => _KeyboardUtil.parseFriendlyKey(key)).join(delimiter);
+  }
+  /**
+   * 将单个按键解析为友好展示
+   * @param {string} key 按键
+   * @returns {string}
+   */
+  static parseFriendlyKey(key) {
+    const value = key.toLowerCase();
+    const modifierKey = _KeyboardUtil.getModifierKey(value);
+    if (modifierKey) {
+      return ModifierFriendlyMap[modifierKey];
+    }
+    if (MediaFriendlyMap[value]) {
+      return MediaFriendlyMap[value];
+    }
+    if (NormalFriendlyMap[value]) {
+      return NormalFriendlyMap[value];
+    }
+    if (/^key[a-z]$/.test(value)) {
+      return value.slice(3).toUpperCase();
+    }
+    if (/^digit\d$/.test(value)) {
+      return value.slice(5);
+    }
+    if (/^numpad[1-9]$/.test(value)) {
+      return `Numpad ${value.slice(6)}`;
+    }
+    if (_KeyboardUtil.isFunctionKey(value)) {
+      return value.toUpperCase();
+    }
+    if (/^[a-z]$/.test(value)) {
+      return value.toUpperCase();
+    }
+    if (/^\d$/.test(value)) {
+      return value;
+    }
+    return _KeyboardUtil.upperFirst(key);
+  }
+  /**
+   * 获取修饰键
+   * @param {string} key 按键
+   * @returns {ModifierKey | undefined}
+   */
+  static getModifierKey(key) {
+    return ModifierKeyMap[key.toLowerCase()];
+  }
+  /**
+   * 是否为 Electron 支持的按键
+   * @param {string} key 按键
+   * @returns {boolean}
+   */
+  static isSupportedKey(key) {
+    return _KeyboardUtil.isModifierKey(key) || _KeyboardUtil.isMediaKey(key) || _KeyboardUtil.isSupportedNormalKey(key);
+  }
+  /**
+   * 是否为 Electron 支持的普通按键
+   * @param {string} key 按键
+   * @returns {boolean}
+   */
+  static isSupportedNormalKey(key) {
+    const value = key.toLowerCase();
+    return Object.hasOwn(NormalFriendlyMap, value) || /^key[a-z]$/.test(value) || /^digit\d$/.test(value) || /^numpad[1-9]$/.test(value) || _KeyboardUtil.isFunctionKey(value) || /^[a-z0-9]$/.test(value);
+  }
+  /**
+   * 是否为修饰键
+   * @param {string} key 按键
+   * @returns {boolean}
+   */
+  static isModifierKey(key) {
+    return _KeyboardUtil.getModifierKey(key) !== void 0;
+  }
+  /**
+   * 是否为媒体键
+   * @param {string} key 按键
+   * @returns {boolean}
+   */
+  static isMediaKey(key) {
+    return Object.hasOwn(MediaFriendlyMap, key.toLowerCase());
+  }
+  /**
+   * 是否为 Electron 支持的功能键
+   * @param {string} key 按键
+   * @returns {boolean}
+   */
+  static isFunctionKey(key) {
+    return /^f(?:[1-9]|1\d|2[0-4])$/i.test(key);
+  }
+  /**
+   * 组合键排序
+   * @param {string[]} keys 按键组合
+   * @returns {string[]}
+   */
+  static sortKeys(keys) {
+    return [...keys].sort((l, r) => {
+      const lModifier = _KeyboardUtil.getModifierKey(l);
+      const rModifier = _KeyboardUtil.getModifierKey(r);
+      const nOrder = ModifierKeys.length;
+      const lOrder = lModifier ? ModifierKeyOrder[lModifier] : nOrder;
+      const rOrder = rModifier ? ModifierKeyOrder[rModifier] : nOrder;
+      if (lOrder !== rOrder) {
+        return lOrder - rOrder;
+      }
+      if (lModifier) {
+        return 0;
+      }
+      return l.toLowerCase().localeCompare(r.toLowerCase());
+    });
+  }
+  /**
+   * 首字母大写
+   * @param {string} value 字符串
+   * @returns {string}
+   */
+  static upperFirst(value) {
+    return value ? `${value.charAt(0).toUpperCase()}${value.slice(1)}` : "";
+  }
+};
+
+// src/renderer/utils/message-util.ts
+import { ElMessage, ElMessageBox, ElNotification } from "element-plus";
+var MessageUtil = class _MessageUtil {
+  //<editor-fold desc="Message">
+  /**
+   * 默认消息配置
+   * @type {XoMessageOptions}
+   * @private
+   */
+  static defaultOptions = {
+    duration: 3e3,
+    grouping: true,
+    offset: 16
+  };
+  /**
+   * 打开消息
+   * @param {MessageOptions} options 消息配置
+   * @returns {MessageHandler}
+   */
+  static open(options) {
+    const placement = options.placement ?? _MessageUtil.defaultOptions.placement ?? "top";
+    const defaultOffset = _MessageUtil.defaultOptions.offset ?? 16;
+    const offset = placement.startsWith("bottom") ? defaultOffset : defaultOffset + (window.xionTitleBar?.height ?? 0);
+    return ElMessage({
+      ..._MessageUtil.defaultOptions,
+      ...options,
+      offset: options.offset ?? offset
+    });
+  }
+  /**
+   * 显示指定类型消息
+   * @param {MessageType}      type    消息类型
+   * @param {XoMessageContent} message 消息内容
+   * @param {XoMessageOptions} options 消息配置
+   * @returns {MessageHandler}
+   * @private
+   */
+  static show(type, message, options) {
+    return _MessageUtil.open({
+      ...options,
+      type,
+      message
+    });
+  }
+  /**
+   * 成功消息
+   * @param {XoMessageContent} message 消息内容
+   * @param {XoMessageOptions} options 消息配置
+   * @returns {MessageHandler}
+   */
+  static success(message, options = {}) {
+    return _MessageUtil.show("success", message, options);
+  }
+  /**
+   * 主要消息
+   * @param {XoMessageContent} message 消息内容
+   * @param {XoMessageOptions} options 消息配置
+   * @returns {MessageHandler}
+   */
+  static primary(message, options = {}) {
+    return _MessageUtil.show("primary", message, options);
+  }
+  /**
+   * 信息消息
+   * @param {XoMessageContent} message 消息内容
+   * @param {XoMessageOptions} options 消息配置
+   * @returns {MessageHandler}
+   */
+  static info(message, options = {}) {
+    return _MessageUtil.show("info", message, options);
+  }
+  /**
+   * 警告消息
+   * @param {XoMessageContent} message 消息内容
+   * @param {XoMessageOptions} options 消息配置
+   * @returns {MessageHandler}
+   */
+  static warning(message, options = {}) {
+    return _MessageUtil.show("warning", message, options);
+  }
+  /**
+   * 错误消息
+   * @param {unknown}                    error           错误
+   * @param {string | XoMessageOptions}  fallbackOptions 兜底消息或消息配置
+   * @param {XoMessageOptions}           options         消息配置
+   * @returns {MessageHandler}
+   */
+  static error(error, fallbackOptions = "\u64CD\u4F5C\u5931\u8D25", options = {}) {
+    const fallback = typeof fallbackOptions === "string" ? fallbackOptions : "\u64CD\u4F5C\u5931\u8D25";
+    const config = typeof fallbackOptions === "string" ? options : fallbackOptions;
+    return _MessageUtil.show("error", _MessageUtil.parseErrorMessage(error, fallback), config);
+  }
+  /**
+   * 关闭全部消息
+   * @param {MessageType} type 消息类型
+   */
+  static closeAll(type) {
+    ElMessage.closeAll(type);
+  }
+  /**
+   * 解析错误消息
+   * @param {unknown} error    错误
+   * @param {string}  fallback 兜底消息
+   * @returns {string}
+   * @private
+   */
+  static parseErrorMessage(error, fallback) {
+    if (typeof error === "string") {
+      return error.trim() || fallback;
+    }
+    if (error instanceof Error) {
+      return error.message || fallback;
+    }
+    if (_MessageUtil.isMessageObject(error)) {
+      return error.message.trim() || fallback;
+    }
+    return fallback;
+  }
+  /**
+   * 判断是否为包含 message 的对象
+   * @param {unknown} value 值
+   * @returns {value is {message: string}}
+   * @private
+   */
+  static isMessageObject(value) {
+    return typeof value === "object" && value !== null && "message" in value && typeof value.message === "string";
+  }
+  //</editor-fold>
+  //<editor-fold desc="Notification">
+  /**
+   * 打开通知
+   * @param {NotificationOptions} options 通知配置
+   * @returns {NotificationHandle}
+   */
+  static notify(options) {
+    const position = options.position ?? "top-right";
+    const offset = position.startsWith("bottom") ? 0 : window.xionTitleBar?.height ?? 0;
+    return ElNotification({
+      ...options,
+      offset: options.offset ?? offset
+    });
+  }
+  /**
+   * 关闭全部通知
+   */
+  static closeAllNotifications() {
+    ElNotification.closeAll();
+  }
+  //</editor-fold>
+  //<editor-fold desc="MessageBox">
+  /**
+   * 默认消息弹窗配置
+   * @type {XoMessageBoxOptions}
+   * @private
+   */
+  static defaultBoxOptions = {
+    confirmButtonText: "\u786E\u5B9A",
+    cancelButtonText: "\u53D6\u6D88"
+  };
+  /**
+   * 警告弹窗
+   * @param {XoMessageBoxContent}          message      消息内容
+   * @param {string | XoMessageBoxOptions} titleOptions 标题
+   * @param {XoMessageBoxOptions}          options      消息弹窗配置
+   * @returns {Promise<void>}
+   */
+  static async alert(message, titleOptions = "\u63D0\u793A", options = {}) {
+    const title = typeof titleOptions === "string" ? titleOptions : "\u63D0\u793A";
+    const config = typeof titleOptions === "string" ? options : titleOptions;
+    try {
+      await ElMessageBox.alert(message, title, {
+        ..._MessageUtil.defaultBoxOptions,
+        ...config
+      });
+    } catch (reason) {
+      if (!_MessageUtil.isBoxDismissed(reason)) {
+        throw reason;
+      }
+    }
+  }
+  /**
+   * 确认弹窗
+   * @param {XoMessageBoxContent}          message      消息内容
+   * @param {string | XoMessageBoxOptions} titleOptions 标题
+   * @param {XoMessageBoxOptions}          options      消息弹窗配置
+   * @returns {Promise<boolean>} 是否确认
+   */
+  static async confirm(message, titleOptions = "\u63D0\u793A", options = {}) {
+    const title = typeof titleOptions === "string" ? titleOptions : "\u63D0\u793A";
+    const config = typeof titleOptions === "string" ? options : titleOptions;
+    try {
+      await ElMessageBox.confirm(message, title, {
+        ..._MessageUtil.defaultBoxOptions,
+        ...config
+      });
+      return true;
+    } catch (reason) {
+      if (_MessageUtil.isBoxDismissed(reason)) {
+        return false;
+      }
+      throw reason;
+    }
+  }
+  /**
+   * 输入弹窗
+   * @param {XoMessageBoxContent}          message      消息内容
+   * @param {string | XoMessageBoxOptions} titleOptions 标题
+   * @param {XoMessageBoxOptions}          options      消息弹窗配置
+   * @returns {Promise<string | undefined>} 输入值，取消或关闭时返回 undefined
+   */
+  static async prompt(message, titleOptions = "\u63D0\u793A", options = {}) {
+    const title = typeof titleOptions === "string" ? titleOptions : "\u63D0\u793A";
+    const config = typeof titleOptions === "string" ? options : titleOptions;
+    try {
+      const { value } = await ElMessageBox.prompt(message, title, {
+        ..._MessageUtil.defaultBoxOptions,
+        ...config
+      });
+      return value;
+    } catch (reason) {
+      if (_MessageUtil.isBoxDismissed(reason)) {
+        return void 0;
+      }
+      throw reason;
+    }
+  }
+  //</editor-fold>
+  /**
+   * 关闭当前消息弹窗
+   */
+  static closeBox() {
+    ElMessageBox.close();
+  }
+  /**
+   * 判断消息弹窗是否被取消或关闭
+   * @param {unknown} reason Promise 拒绝原因
+   * @returns {boolean}
+   * @private
+   */
+  static isBoxDismissed(reason) {
+    return reason === "cancel" || reason === "close";
+  }
+  //</editor-fold>
+};
+
+// src/shared/utils/log-util.ts
+var MaxMessageLength = 16 * 1024;
+var MaxValueLength = 8 * 1024;
+var MaxDataItems = 100;
+var MaxCollectionItems = 100;
+var MaxDepth = 10;
+var MaxNodes = 500;
+var LogUtil = class _LogUtil {
+  /**
+   * 标准化渲染进程日志请求
+   * @param {unknown} message 日志消息
+   * @param {unknown} data    附加数据
+   * @returns {XoIpcLogger.Request}
+   */
+  static normalizeRequest(message, data) {
+    const budget = { remaining: MaxNodes };
+    const seen = /* @__PURE__ */ new WeakSet();
+    return {
+      message: _LogUtil.normalizeText(typeof message === "string" ? message : String(message ?? ""), MaxMessageLength),
+      data: (Array.isArray(data) ? data : []).slice(0, MaxDataItems).map((value) => _LogUtil.normalizeValue(value, 0, seen, budget))
+    };
+  }
+  /**
+   * 标准化日志值
+   * @param {unknown}         value            原始值
+   * @param {number}          depth            当前深度
+   * @param {WeakSet<object>} seen             已处理对象
+   * @param {NormalizeBudget} budget           处理预算
+   * @param {boolean}         preserveNewlines 是否保留换行
+   * @returns {XoIpcLogger.Value}
+   * @private
+   */
+  static normalizeValue(value, depth, seen, budget, preserveNewlines = false) {
+    if (budget.remaining <= 0) return "[Truncated]";
+    budget.remaining--;
+    if (value === null) return null;
+    if (typeof value === "string") return _LogUtil.normalizeText(value, MaxValueLength, preserveNewlines);
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "undefined") return "[undefined]";
+    if (typeof value === "symbol") return `[Symbol ${value.description ?? ""}]`;
+    if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? "[Invalid Date]" : value.toISOString();
+    }
+    if (value instanceof Error) {
+      return {
+        name: _LogUtil.normalizeText(value.name, MaxValueLength),
+        message: _LogUtil.normalizeText(value.message, MaxValueLength),
+        stack: _LogUtil.normalizeText(value.stack ?? "", MaxValueLength, true)
+      };
+    }
+    if (depth >= MaxDepth) return "[Max Depth]";
+    if (seen.has(value)) return "[Circular]";
+    seen.add(value);
+    try {
+      if (Array.isArray(value)) {
+        return value.slice(0, MaxCollectionItems).map((item) => _LogUtil.normalizeValue(item, depth + 1, seen, budget));
+      }
+      return Object.fromEntries(
+        Object.entries(value).slice(0, MaxCollectionItems).map(([key, item]) => [
+          _LogUtil.normalizeText(key, 128),
+          _LogUtil.normalizeValue(item, depth + 1, seen, budget, key === "stack")
+        ])
+      );
+    } catch {
+      return "[Unserializable Object]";
+    } finally {
+      seen.delete(value);
+    }
+  }
+  /**
+   * 清理日志文本中的控制字符并限制长度
+   * @param {string}  text             原始文本
+   * @param {number}  maxLength        最大长度
+   * @param {boolean} preserveNewlines 是否保留换行
+   * @returns {string}
+   * @private
+   */
+  static normalizeText(text, maxLength, preserveNewlines = false) {
+    const normalized = preserveNewlines ? text.replace(/\r\n?/g, "\n") : text.replace(/\r\n?|\n/g, "\\n");
+    return normalized.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").slice(0, maxLength);
+  }
+};
+
+// src/renderer/utils/renderer-log-util.ts
+var RendererLogUtil = class _RendererLogUtil {
+  /**
+   * 写入 debug 日志
+   * @param {string}    message 日志消息
+   * @param {unknown[]} data    附加数据
+   * @returns {Promise<void>}
+   */
+  static async debug(message, ...data) {
+    await _RendererLogUtil.write("debug", message, data);
+  }
+  /**
+   * 写入 info 日志
+   * @param {string}    message 日志消息
+   * @param {unknown[]} data    附加数据
+   * @returns {Promise<void>}
+   */
+  static async info(message, ...data) {
+    await _RendererLogUtil.write("info", message, data);
+  }
+  /**
+   * 写入 warn 日志
+   * @param {string}    message 日志消息
+   * @param {unknown[]} data    附加数据
+   * @returns {Promise<void>}
+   */
+  static async warn(message, ...data) {
+    await _RendererLogUtil.write("warn", message, data);
+  }
+  /**
+   * 写入 error 日志
+   * @param {string}    message 日志消息
+   * @param {unknown[]} data    附加数据
+   * @returns {Promise<void>}
+   */
+  static async error(message, ...data) {
+    await _RendererLogUtil.write("error", message, data);
+  }
+  /**
+   * 标准化并写入日志
+   * @param {XoIpcLogger.Level} level   日志等级
+   * @param {string}            message 日志消息
+   * @param {unknown[]}         data    附加数据
+   * @returns {Promise<void>}
+   * @private
+   */
+  static async write(level, message, data) {
+    const normalized = LogUtil.normalizeRequest(message, data);
+    await window.xion.log[level](normalized.message, ...normalized.data);
+  }
+};
+
+// src/renderer/utils/renderer-util.ts
+import { Fragment, isProxy, toRaw } from "vue";
+var RendererUtil = class _RendererUtil {
+  /**
+   * 将字符串转换为 CSS 文本
+   * @param {string | undefined} value 字符串值
+   * @returns {string}
+   */
+  static toCssText(value) {
+    if (value === void 0) {
+      return void 0;
+    }
+    return typeof value === "string" ? value : "";
+  }
+  /**
+   * 将数字转换为 CSS 尺寸
+   * @param {number | string | undefined} value 尺寸值
+   * @returns {string}
+   */
+  static toCssSize(value) {
+    if (value === void 0) {
+      return void 0;
+    }
+    return typeof value === "number" ? `${value}px` : value;
+  }
+  /**
+   * 判断插槽是否有内容
+   * @param {Slots}  slots 插槽对象
+   * @param {string} name  插槽名称
+   * @returns {boolean}
+   */
+  static hasSlot(slots, name) {
+    return _RendererUtil.hasVNodeContent(slots[name]?.() ?? []);
+  }
+  /**
+   * 判断 VNode 是否有内容
+   * @param {VNode[]} nodes VNode 数组
+   * @returns {boolean}
+   */
+  static hasVNodeContent(nodes) {
+    return nodes.some((node) => {
+      if (node.type === Comment) {
+        return false;
+      }
+      if (node.type === Text) {
+        return String(node.children).trim().length > 0;
+      }
+      if (node.type === Fragment) {
+        return Array.isArray(node.children) ? _RendererUtil.hasVNodeContent(node.children) : false;
+      }
+      return true;
+    });
+  }
+  /**
+   * 获取 Vue Proxy 的原始对象
+   */
+  static toRaw(value) {
+    return isProxy(value) ? toRaw(value) : value;
+  }
+};
+
+// src/renderer/utils/router-util.ts
+import { computed as computed2 } from "vue";
+var RouterUtil = class _RouterUtil {
+  /**
+   * 路由实例
+   * @type {Router | undefined}
+   * @private
+   */
+  static router;
+  /**
+   * 路由重定向监听移除方法
+   * @type {(() => void) | undefined}
+   * @private
+   */
+  static offRouteRedirect;
+  /**
+   * 安装路由实例
+   * @param {Router} router 路由实例
+   */
+  static install(router) {
+    this.router = router;
+    this.bindRouteRedirect();
+  }
+  /**
+   * 获取路由实例
+   * @returns {Router}
+   * @private
+   */
+  static getRouter() {
+    if (!this.router) {
+      throw new Error("RouterUtil \u672A\u5B89\u88C5\u8DEF\u7531\u5B9E\u4F8B\uFF0C\u8BF7\u5148\u8C03\u7528 RouterUtil.install(router)");
+    }
+    return this.router;
+  }
+  /**
+   * 绑定路由重定向监听
+   * @private
+   */
+  static bindRouteRedirect() {
+    this.offRouteRedirect?.();
+    this.offRouteRedirect = void 0;
+    if (!window.xion?.window?.onRouteRedirect) {
+      return;
+    }
+    this.offRouteRedirect = window.xion.window.onRouteRedirect((request) => {
+      _RouterUtil.redirectRoute(request);
+    });
+  }
+  /**
+   * 重定向路由
+   * @param {XoWindow.RouteRedirectRequest} request 路由重定向请求
+   * @private
+   */
+  static redirectRoute(request) {
+    const messageTitle = "\u8DEF\u7531\u8DF3\u8F6C\u5931\u8D25";
+    try {
+      const route = request.routeName !== void 0 ? {
+        ...typeof request.route === "object" ? request.route : {},
+        name: request.routeName
+      } : request.route;
+      if (!route) {
+        MessageUtil.error(new Error("\u7F3A\u5C11\u8DEF\u7531\u76EE\u6807"), messageTitle);
+        return;
+      }
+      const router = this.getRouter();
+      const navigation = request.mode === "replace" ? router.replace(route) : router.push(route);
+      void navigation.catch((error) => {
+        MessageUtil.error(error, messageTitle);
+      });
+    } catch (error) {
+      MessageUtil.error(error, messageTitle);
+    }
+  }
+  /**
+   * 获取父路由
+   * @returns {RouteLocationMatched | null}
+   */
+  static getParentRoute() {
+    const matched = this.getRouter().currentRoute.value.matched;
+    return matched.length > 1 ? matched[matched.length - 2] : null;
+  }
+  /**
+   * 获取父路由名称
+   * @returns {string}
+   */
+  static getParentRouteName() {
+    const parentRoute = _RouterUtil.getParentRoute();
+    return typeof parentRoute?.name === "string" ? parentRoute.name : "";
+  }
+  /**
+   * 获取当前路由名称
+   * @returns {ComputedRef<string | symbol | undefined>}
+   */
+  static getCurrentRouteName() {
+    return computed2(() => this.getRouter().currentRoute.value.name);
+  }
+  /**
+   * 判断路由是否激活
+   * @param {XoComponentSidebarMenuRouteName}   routeName    路由名称
+   * @param {XoComponentSidebarMenuRouteName[]} activeRoutes 用于判断是否激活的路由名称数组，如果为空就使用 route 比对
+   * @returns {boolean}
+   */
+  static isRouteActive(routeName, activeRoutes) {
+    const currentName = this.getRouter().currentRoute.value.name;
+    if (!currentName) return false;
+    return activeRoutes?.length ? activeRoutes.includes(currentName) : routeName === currentName;
+  }
+  /**
+   * Router push by name
+   * @param {RouteRecordName} name 路由名称
+   * @param {LocationQueryRaw} query 请求参数
+   */
+  static push(name, query) {
+    void this.getRouter().push({ name, query });
+  }
+  /**
+   * Router push
+   * @param {RouteLocationRaw} to 路由目标
+   */
+  static pushTo(to) {
+    void this.getRouter().push(to);
+  }
+  /**
+   * Router replace by name
+   * @param {RouteRecordName} name 路由名称
+   * @param {LocationQueryRaw} query 请求参数
+   */
+  static replace(name, query) {
+    void this.getRouter().replace({ name, query });
+  }
+  /**
+   * Router replace by name
+   * @param {RouteLocationRaw} to 路由目标
+   */
+  static replaceTo(to) {
+    void this.getRouter().replace(to);
+  }
+  /**
+   * 路由会退
+   */
+  static back() {
+    this.getRouter().back();
+  }
+  /**
+   * 路由前进
+   */
+  static forward() {
+    this.getRouter().forward();
+  }
+  /**
+   * 路由历史跳转
+   * @param {number} delta 跳转步数
+   */
+  static go(delta) {
+    this.getRouter().go(delta);
+  }
+  /**
+   * 获取路由名称
+   * @returns {RouteRecordNameGeneric}
+   */
+  static getName() {
+    return this.getRouter().currentRoute.value.name;
+  }
+  /**
+   * 获取路由路径
+   * @returns {string}
+   */
+  static getPath() {
+    return this.getRouter().currentRoute.value.path;
+  }
+  /**
+   * 获取路由完整路径
+   * @returns {string}
+   */
+  static getFullPath() {
+    return this.getRouter().currentRoute.value.fullPath;
+  }
+  /**
+   * 获取路由元信息
+   * @returns {RouteMeta}
+   */
+  static getMeta() {
+    return this.getRouter().currentRoute.value.meta;
+  }
+  /**
+   * 获取路由参数
+   * @returns {RouteParamsGeneric}
+   */
+  static getParams() {
+    return this.getRouter().currentRoute.value.params;
+  }
+  /**
+   * 获取当前路由指定路径参数的值
+   *
+   * 路由参数由路径中的动态片段产生，例如 /user/:id 的 id
+   * 当参数为数组时，返回数组中的第一个值。
+   *
+   * @param {string} key      参数名
+   * @param {string} defaults 参数不存在时返回的默认值
+   * @returns {string}
+   */
+  static getParam(key, defaults = "") {
+    const value = _RouterUtil.getParams()[key];
+    if (value === void 0 || value === null) {
+      return defaults;
+    }
+    return Array.isArray(value) ? value[0] ?? defaults : value;
+  }
+  /**
+   * 获取当前路由指定路径参数的值数组
+   *
+   * 字符串参数会转换为单元素数组，重复路径参数会完整返回
+   *
+   * @param {string}   key      参数名
+   * @param {string[]} defaults 参数不存在时返回的默认值
+   * @returns {string[]}
+   */
+  static getParamArray(key, defaults = []) {
+    const value = _RouterUtil.getParams()[key];
+    if (value === void 0 || value === null) {
+      return defaults;
+    }
+    return Array.isArray(value) ? value : [value];
+  }
+  /**
+   * 获取请求参数映射
+   * @returns {LocationQuery}
+   */
+  static getQueryMap() {
+    return this.getRouter().currentRoute.value.query;
+  }
+  /**
+   * 获取请求参数的值的数组，单个结果也按数组返回
+   * @param {string}   key      参数名
+   * @param {string[]} defaults 默认值
+   * @returns {string[]}
+   */
+  static getQueryArray(key, defaults = []) {
+    const values = _RouterUtil.getQueryMap()[key];
+    if (values === void 0 || values === null) {
+      return defaults;
+    }
+    return Array.isArray(values) ? values.filter((value) => value !== null) : [values];
+  }
+  /**
+   * 获取请求参数的值，如果值是数组，取第一个值返回
+   * @param {string} key      参数名
+   * @param {string} defaults 默认值
+   * @returns {string}
+   */
+  static getQuery(key, defaults = "") {
+    return _RouterUtil.getQueryArray(key)[0] ?? defaults;
+  }
+  /**
+   * location 重定向
+   * @param {string} url 重定向地址
+   */
+  static locationRedirect(url) {
+    window.location.href = url;
+  }
+  /**
+   * location 刷新
+   */
+  static locationReload() {
+    window.location.reload();
+  }
+  /**
+   * 获取当前页面 href 路径
+   * @returns {string}
+   */
+  static getLocationHref() {
+    return window.location.href;
+  }
+  /**
+   * 拨打电话链接
+   * @param {string} tel 电话号码
+   * @returns {string}
+   */
+  static tel(tel) {
+    return `tel:${tel}`;
+  }
+};
+
+// src/renderer/utils/shortcut-util.ts
+var ShortcutUtil = class {
+  /**
+   * 创建全局快捷键
+   * @param {XoShortcut.ID} id   快捷键ID
+   * @param {string[]}      keys 按键组合
+   * @returns {XoShortcut.Key}
+   */
+  static globalKey(id, keys) {
+    return {
+      id,
+      keys,
+      enabled: true,
+      scope: "global"
+    };
+  }
+  /**
+   * 创建应用级快捷键
+   * @param {XoShortcut.ID} id   快捷键ID
+   * @param {string[]}      keys 按键组合
+   * @returns {XoShortcut.Key}
+   */
+  static appKey(id, keys) {
+    return {
+      id,
+      keys,
+      enabled: true,
+      scope: "app"
+    };
+  }
+};
+
+// src/renderer/utils/storage-util.ts
+var prefix = "StorageUtil:";
+var StorageUtil = class {
+  /**
+   * 保存数据
+   * @template T 数据类型
+   * @param {string} key       键
+   * @param {T}      value     值
+   * @param {number} expiresIn 可选有效期，单位毫秒，不传表示永不过期
+   * @returns {void}
+   * @throws {RangeError} 有效期不是大于 0 的有限数字时抛出
+   * @example
+   *   // 不过期保存
+   *   StorageUtil.save('login.authType', 'totp')
+   *
+   *   // 24 小时后过期
+   *   StorageUtil.save('login.authType', 'totp', 24 * 60 * 60 * 1000)
+   */
+  static save(key, value, expiresIn) {
+    if (key === "") {
+      return;
+    }
+    if (expiresIn !== void 0 && (!Number.isFinite(expiresIn) || expiresIn <= 0)) {
+      throw new RangeError("\u7F13\u5B58\u6709\u6548\u671F\u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6570\u5B57");
+    }
+    const entry = {
+      expiresAt: expiresIn === void 0 ? null : Date.now() + expiresIn,
+      value
+    };
+    window.localStorage.setItem(`${prefix}${key}`, JSON.stringify(entry));
+  }
+  /**
+   * 获取数据
+   * <p>数据不存在、过期或内容无效时返回 null</p>
+   * @template T 数据类型
+   * @param {string} key 键
+   * @returns {T | null} 缓存数据
+   * @example
+   *   // 获取数据，过期后返回 null 并自动删除
+   *   const value = StorageUtil.get<T>('key')
+   */
+  static get(key) {
+    const result = this.read(key);
+    return result?.value ?? null;
+  }
+  /**
+   * 判断数据是否存在且未过期
+   * @param {string} key 键
+   * @returns {boolean} 数据是否存在且未过期
+   * @example
+   *   // 判断是否存在且未过期
+   *   const exists = StorageUtil.has('key')
+   */
+  static has(key) {
+    return this.read(key) !== null;
+  }
+  /**
+   * 删除数据
+   * @param {string} key 键
+   * @returns {void}
+   * @example
+   *   // 删除指定缓存
+   *   StorageUtil.remove('key')
+   */
+  static remove(key) {
+    if (key === "") {
+      return;
+    }
+    window.localStorage.removeItem(`${prefix}${key}`);
+  }
+  /**
+   * 清理全部由 StorageUtil 保存且已经过期的数据
+   * <p>不会删除普通 localStorage 数据和旧版未包装数据</p>
+   * @returns {number} 删除的数据数量
+   * @example
+   *   // 清理全部由 StorageUtil 保存且已过期的数据
+   *   const count = StorageUtil.clearExpired()
+   */
+  static clearExpired() {
+    const expiredKeys = [];
+    for (let index = 0; index < window.localStorage.length; index++) {
+      const key = window.localStorage.key(index);
+      if (key === null) {
+        continue;
+      }
+      const data = window.localStorage.getItem(key);
+      if (data === null) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(data);
+        if (this.isStorageEntry(parsed) && this.isExpired(parsed)) {
+          expiredKeys.push(key);
+        }
+      } catch {
+      }
+    }
+    expiredKeys.forEach((key) => window.localStorage.removeItem(key));
+    return expiredKeys.length;
+  }
+  /**
+   * 读取并校验存储数据
+   * @template T 数据类型
+   * @param {string} key 键
+   * @returns {{value: T} | null} 有效数据，不存在或无效时返回 null
+   * @private
+   */
+  static read(key) {
+    if (key === "") {
+      return null;
+    }
+    const data = window.localStorage.getItem(`${prefix}${key}`);
+    if (data === null) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(data);
+      if (!this.isStorageEntry(parsed)) {
+        return null;
+      }
+      if (this.isExpired(parsed)) {
+        window.localStorage.removeItem(`${prefix}${key}`);
+        return null;
+      }
+      return {
+        value: parsed.value
+      };
+    } catch {
+      window.localStorage.removeItem(`${prefix}${key}`);
+      return null;
+    }
+  }
+  /**
+   * 判断数据是否为 StorageUtil 包装结构
+   * @param {unknown} value 待判断数据
+   * @returns {value is Entry<unknown>} 是否为 StorageUtil 包装结构
+   * @private
+   */
+  static isStorageEntry(value) {
+    if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
+      return false;
+    }
+    const entry = value;
+    return (entry.expiresAt === null || typeof entry.expiresAt === "number") && Object.hasOwn(entry, "value");
+  }
+  /**
+   * 判断存储数据是否已经过期
+   * @param {Entry<unknown>} entry 存储数据
+   * @returns {boolean} 是否已经过期
+   * @private
+   */
+  static isExpired(entry) {
+    return entry.expiresAt !== null && entry.expiresAt <= Date.now();
+  }
+};
+export {
+  AuthRouteUtil,
+  ContextUtil,
+  ErrorUtil,
+  KeyboardUtil,
+  MessageUtil,
+  RendererLogUtil,
+  RendererUtil,
+  RouterUtil,
+  ShortcutUtil,
+  StorageUtil
+};